Towards 8-bit Strings: Move Lexer and Parser Objects out of JSGlobalData
authormsaboff@apple.com <msaboff@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 31 Oct 2011 22:13:01 +0000 (22:13 +0000)
committermsaboff@apple.com <msaboff@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 31 Oct 2011 22:13:01 +0000 (22:13 +0000)
https://bugs.webkit.org/show_bug.cgi?id=71138

Restructure and movement of Lexer and Parser code.
Moved Lexer and Parser objects out of JSGlobalData.
Added a new ParserTokens class and instance to JSGlobalData that
have JavaScript token related definitions.
Replaced JSGlobalData arguments to Node classes with lineNumber,
as that was the only use of the JSGlobalData.
Combined JSParser and Parser classes into one class,
eliminating JSParser.h and .cpp.
Various supporting #include changes.

These mostly mechanical changes are done in preparation to
making the Lexer and Parser template classes.

Reviewed by Darin Adler.

* CMakeLists.txt:
* GNUmakefile.list.am:
* JavaScriptCore.gypi:
* JavaScriptCore.pro:
* JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
* JavaScriptCore.xcodeproj/project.pbxproj:
* bytecompiler/NodesCodegen.cpp:
(JSC::ArrayNode::toArgumentList):
(JSC::ApplyFunctionCallDotNode::emitBytecode):
* parser/ASTBuilder.h:
(JSC::ASTBuilder::ASTBuilder):
(JSC::ASTBuilder::createSourceElements):
(JSC::ASTBuilder::createCommaExpr):
(JSC::ASTBuilder::createLogicalNot):
(JSC::ASTBuilder::createUnaryPlus):
(JSC::ASTBuilder::createVoid):
(JSC::ASTBuilder::thisExpr):
(JSC::ASTBuilder::createResolve):
(JSC::ASTBuilder::createObjectLiteral):
(JSC::ASTBuilder::createArray):
(JSC::ASTBuilder::createNumberExpr):
(JSC::ASTBuilder::createString):
(JSC::ASTBuilder::createBoolean):
(JSC::ASTBuilder::createNull):
(JSC::ASTBuilder::createBracketAccess):
(JSC::ASTBuilder::createDotAccess):
(JSC::ASTBuilder::createRegExp):
(JSC::ASTBuilder::createNewExpr):
(JSC::ASTBuilder::createConditionalExpr):
(JSC::ASTBuilder::createAssignResolve):
(JSC::ASTBuilder::createFunctionExpr):
(JSC::ASTBuilder::createFunctionBody):
(JSC::ASTBuilder::createGetterOrSetterProperty):
(JSC::ASTBuilder::createArguments):
(JSC::ASTBuilder::createArgumentsList):
(JSC::ASTBuilder::createPropertyList):
(JSC::ASTBuilder::createElementList):
(JSC::ASTBuilder::createFormalParameterList):
(JSC::ASTBuilder::createClause):
(JSC::ASTBuilder::createClauseList):
(JSC::ASTBuilder::createFuncDeclStatement):
(JSC::ASTBuilder::createBlockStatement):
(JSC::ASTBuilder::createExprStatement):
(JSC::ASTBuilder::createIfStatement):
(JSC::ASTBuilder::createForLoop):
(JSC::ASTBuilder::createForInLoop):
(JSC::ASTBuilder::createEmptyStatement):
(JSC::ASTBuilder::createVarStatement):
(JSC::ASTBuilder::createReturnStatement):
(JSC::ASTBuilder::createBreakStatement):
(JSC::ASTBuilder::createContinueStatement):
(JSC::ASTBuilder::createTryStatement):
(JSC::ASTBuilder::createSwitchStatement):
(JSC::ASTBuilder::createWhileStatement):
(JSC::ASTBuilder::createDoWhileStatement):
(JSC::ASTBuilder::createLabelStatement):
(JSC::ASTBuilder::createWithStatement):
(JSC::ASTBuilder::createThrowStatement):
(JSC::ASTBuilder::createDebugger):
(JSC::ASTBuilder::createConstStatement):
(JSC::ASTBuilder::appendConstDecl):
(JSC::ASTBuilder::combineCommaNodes):
(JSC::ASTBuilder::appendBinaryOperation):
(JSC::ASTBuilder::createAssignment):
(JSC::ASTBuilder::createNumber):
(JSC::ASTBuilder::makeTypeOfNode):
(JSC::ASTBuilder::makeDeleteNode):
(JSC::ASTBuilder::makeNegateNode):
(JSC::ASTBuilder::makeBitwiseNotNode):
(JSC::ASTBuilder::makeMultNode):
(JSC::ASTBuilder::makeDivNode):
(JSC::ASTBuilder::makeModNode):
(JSC::ASTBuilder::makeAddNode):
(JSC::ASTBuilder::makeSubNode):
(JSC::ASTBuilder::makeLeftShiftNode):
(JSC::ASTBuilder::makeRightShiftNode):
(JSC::ASTBuilder::makeURightShiftNode):
(JSC::ASTBuilder::makeBitOrNode):
(JSC::ASTBuilder::makeBitAndNode):
(JSC::ASTBuilder::makeBitXOrNode):
(JSC::ASTBuilder::makeFunctionCallNode):
(JSC::ASTBuilder::makeBinaryNode):
(JSC::ASTBuilder::makeAssignNode):
(JSC::ASTBuilder::makePrefixNode):
(JSC::ASTBuilder::makePostfixNode):
* parser/JSParser.cpp: Removed.
* parser/JSParser.h: Removed.
* parser/Lexer.cpp:
(JSC::Keywords::Keywords):
(JSC::Lexer::Lexer):
(JSC::Lexer::~Lexer):
(JSC::Lexer::setCode):
(JSC::Lexer::parseIdentifier):
* parser/Lexer.h:
(JSC::Keywords::isKeyword):
(JSC::Keywords::getKeyword):
(JSC::Keywords::~Keywords):
(JSC::Lexer::setIsReparsing):
(JSC::Lexer::isReparsing):
(JSC::Lexer::lineNumber):
(JSC::Lexer::setLastLineNumber):
(JSC::Lexer::lastLineNumber):
(JSC::Lexer::prevTerminator):
(JSC::Lexer::sawError):
(JSC::Lexer::getErrorMessage):
(JSC::Lexer::currentOffset):
(JSC::Lexer::setOffset):
(JSC::Lexer::setLineNumber):
(JSC::Lexer::sourceProvider):
(JSC::Lexer::isWhiteSpace):
(JSC::Lexer::isLineTerminator):
(JSC::Lexer::convertHex):
(JSC::Lexer::convertUnicode):
(JSC::Lexer::makeIdentifier):
(JSC::Lexer::lexExpectIdentifier):
* parser/NodeConstructors.h:
(JSC::ParserArenaFreeable::operator new):
(JSC::ParserArenaDeletable::operator new):
(JSC::ParserArenaRefCounted::ParserArenaRefCounted):
(JSC::Node::Node):
(JSC::ExpressionNode::ExpressionNode):
(JSC::StatementNode::StatementNode):
(JSC::NullNode::NullNode):
(JSC::BooleanNode::BooleanNode):
(JSC::NumberNode::NumberNode):
(JSC::StringNode::StringNode):
(JSC::RegExpNode::RegExpNode):
(JSC::ThisNode::ThisNode):
(JSC::ResolveNode::ResolveNode):
(JSC::ElementNode::ElementNode):
(JSC::ArrayNode::ArrayNode):
(JSC::PropertyNode::PropertyNode):
(JSC::PropertyListNode::PropertyListNode):
(JSC::ObjectLiteralNode::ObjectLiteralNode):
(JSC::BracketAccessorNode::BracketAccessorNode):
(JSC::DotAccessorNode::DotAccessorNode):
(JSC::ArgumentListNode::ArgumentListNode):
(JSC::ArgumentsNode::ArgumentsNode):
(JSC::NewExprNode::NewExprNode):
(JSC::EvalFunctionCallNode::EvalFunctionCallNode):
(JSC::FunctionCallValueNode::FunctionCallValueNode):
(JSC::FunctionCallResolveNode::FunctionCallResolveNode):
(JSC::FunctionCallBracketNode::FunctionCallBracketNode):
(JSC::FunctionCallDotNode::FunctionCallDotNode):
(JSC::CallFunctionCallDotNode::CallFunctionCallDotNode):
(JSC::ApplyFunctionCallDotNode::ApplyFunctionCallDotNode):
(JSC::PrePostResolveNode::PrePostResolveNode):
(JSC::PostfixResolveNode::PostfixResolveNode):
(JSC::PostfixBracketNode::PostfixBracketNode):
(JSC::PostfixDotNode::PostfixDotNode):
(JSC::PostfixErrorNode::PostfixErrorNode):
(JSC::DeleteResolveNode::DeleteResolveNode):
(JSC::DeleteBracketNode::DeleteBracketNode):
(JSC::DeleteDotNode::DeleteDotNode):
(JSC::DeleteValueNode::DeleteValueNode):
(JSC::VoidNode::VoidNode):
(JSC::TypeOfResolveNode::TypeOfResolveNode):
(JSC::TypeOfValueNode::TypeOfValueNode):
(JSC::PrefixResolveNode::PrefixResolveNode):
(JSC::PrefixBracketNode::PrefixBracketNode):
(JSC::PrefixDotNode::PrefixDotNode):
(JSC::PrefixErrorNode::PrefixErrorNode):
(JSC::UnaryOpNode::UnaryOpNode):
(JSC::UnaryPlusNode::UnaryPlusNode):
(JSC::NegateNode::NegateNode):
(JSC::BitwiseNotNode::BitwiseNotNode):
(JSC::LogicalNotNode::LogicalNotNode):
(JSC::BinaryOpNode::BinaryOpNode):
(JSC::MultNode::MultNode):
(JSC::DivNode::DivNode):
(JSC::ModNode::ModNode):
(JSC::AddNode::AddNode):
(JSC::SubNode::SubNode):
(JSC::LeftShiftNode::LeftShiftNode):
(JSC::RightShiftNode::RightShiftNode):
(JSC::UnsignedRightShiftNode::UnsignedRightShiftNode):
(JSC::LessNode::LessNode):
(JSC::GreaterNode::GreaterNode):
(JSC::LessEqNode::LessEqNode):
(JSC::GreaterEqNode::GreaterEqNode):
(JSC::ThrowableBinaryOpNode::ThrowableBinaryOpNode):
(JSC::InstanceOfNode::InstanceOfNode):
(JSC::InNode::InNode):
(JSC::EqualNode::EqualNode):
(JSC::NotEqualNode::NotEqualNode):
(JSC::StrictEqualNode::StrictEqualNode):
(JSC::NotStrictEqualNode::NotStrictEqualNode):
(JSC::BitAndNode::BitAndNode):
(JSC::BitOrNode::BitOrNode):
(JSC::BitXOrNode::BitXOrNode):
(JSC::LogicalOpNode::LogicalOpNode):
(JSC::ConditionalNode::ConditionalNode):
(JSC::ReadModifyResolveNode::ReadModifyResolveNode):
(JSC::AssignResolveNode::AssignResolveNode):
(JSC::ReadModifyBracketNode::ReadModifyBracketNode):
(JSC::AssignBracketNode::AssignBracketNode):
(JSC::AssignDotNode::AssignDotNode):
(JSC::ReadModifyDotNode::ReadModifyDotNode):
(JSC::AssignErrorNode::AssignErrorNode):
(JSC::CommaNode::CommaNode):
(JSC::ConstStatementNode::ConstStatementNode):
(JSC::SourceElements::SourceElements):
(JSC::EmptyStatementNode::EmptyStatementNode):
(JSC::DebuggerStatementNode::DebuggerStatementNode):
(JSC::ExprStatementNode::ExprStatementNode):
(JSC::VarStatementNode::VarStatementNode):
(JSC::IfNode::IfNode):
(JSC::IfElseNode::IfElseNode):
(JSC::DoWhileNode::DoWhileNode):
(JSC::WhileNode::WhileNode):
(JSC::ForNode::ForNode):
(JSC::ContinueNode::ContinueNode):
(JSC::BreakNode::BreakNode):
(JSC::ReturnNode::ReturnNode):
(JSC::WithNode::WithNode):
(JSC::LabelNode::LabelNode):
(JSC::ThrowNode::ThrowNode):
(JSC::TryNode::TryNode):
(JSC::ParameterNode::ParameterNode):
(JSC::FuncExprNode::FuncExprNode):
(JSC::FuncDeclNode::FuncDeclNode):
(JSC::CaseClauseNode::CaseClauseNode):
(JSC::ClauseListNode::ClauseListNode):
(JSC::CaseBlockNode::CaseBlockNode):
(JSC::SwitchNode::SwitchNode):
(JSC::ConstDeclNode::ConstDeclNode):
(JSC::BlockNode::BlockNode):
(JSC::ForInNode::ForInNode):
* parser/NodeInfo.h:
* parser/Nodes.cpp:
(JSC::StatementNode::setLoc):
(JSC::ScopeNode::ScopeNode):
(JSC::ProgramNode::ProgramNode):
(JSC::ProgramNode::create):
(JSC::EvalNode::EvalNode):
(JSC::EvalNode::create):
(JSC::FunctionBodyNode::FunctionBodyNode):
(JSC::FunctionBodyNode::create):
* parser/Nodes.h:
(JSC::Node::lineNo):
* parser/Parser.cpp:
(JSC::Parser::Parser):
(JSC::Parser::~Parser):
(JSC::Parser::parseInner):
(JSC::Parser::allowAutomaticSemicolon):
(JSC::Parser::parseSourceElements):
(JSC::Parser::parseVarDeclaration):
(JSC::Parser::parseConstDeclaration):
(JSC::Parser::parseDoWhileStatement):
(JSC::Parser::parseWhileStatement):
(JSC::Parser::parseVarDeclarationList):
(JSC::Parser::parseConstDeclarationList):
(JSC::Parser::parseForStatement):
(JSC::Parser::parseBreakStatement):
(JSC::Parser::parseContinueStatement):
(JSC::Parser::parseReturnStatement):
(JSC::Parser::parseThrowStatement):
(JSC::Parser::parseWithStatement):
(JSC::Parser::parseSwitchStatement):
(JSC::Parser::parseSwitchClauses):
(JSC::Parser::parseSwitchDefaultClause):
(JSC::Parser::parseTryStatement):
(JSC::Parser::parseDebuggerStatement):
(JSC::Parser::parseBlockStatement):
(JSC::Parser::parseStatement):
(JSC::Parser::parseFormalParameters):
(JSC::Parser::parseFunctionBody):
(JSC::Parser::parseFunctionInfo):
(JSC::Parser::parseFunctionDeclaration):
(JSC::LabelInfo::LabelInfo):
(JSC::Parser::parseExpressionOrLabelStatement):
(JSC::Parser::parseExpressionStatement):
(JSC::Parser::parseIfStatement):
(JSC::Parser::parseExpression):
(JSC::Parser::parseAssignmentExpression):
(JSC::Parser::parseConditionalExpression):
(JSC::isUnaryOp):
(JSC::Parser::isBinaryOperator):
(JSC::Parser::parseBinaryExpression):
(JSC::Parser::parseProperty):
(JSC::Parser::parseObjectLiteral):
(JSC::Parser::parseStrictObjectLiteral):
(JSC::Parser::parseArrayLiteral):
(JSC::Parser::parsePrimaryExpression):
(JSC::Parser::parseArguments):
(JSC::Parser::parseMemberExpression):
(JSC::Parser::parseUnaryExpression):
* parser/Parser.h:
(JSC::isEvalNode):
(JSC::EvalNode):
(JSC::DepthManager::DepthManager):
(JSC::DepthManager::~DepthManager):
(JSC::ScopeLabelInfo::ScopeLabelInfo):
(JSC::Scope::Scope):
(JSC::Scope::startSwitch):
(JSC::Scope::endSwitch):
(JSC::Scope::startLoop):
(JSC::Scope::endLoop):
(JSC::Scope::inLoop):
(JSC::Scope::breakIsValid):
(JSC::Scope::continueIsValid):
(JSC::Scope::pushLabel):
(JSC::Scope::popLabel):
(JSC::Scope::getLabel):
(JSC::Scope::setIsFunction):
(JSC::Scope::isFunction):
(JSC::Scope::isFunctionBoundary):
(JSC::Scope::declareVariable):
(JSC::Scope::declareWrite):
(JSC::Scope::preventNewDecls):
(JSC::Scope::allowsNewDecls):
(JSC::Scope::declareParameter):
(JSC::Scope::useVariable):
(JSC::Scope::setNeedsFullActivation):
(JSC::Scope::collectFreeVariables):
(JSC::Scope::getUncapturedWrittenVariables):
(JSC::Scope::getCapturedVariables):
(JSC::Scope::setStrictMode):
(JSC::Scope::strictMode):
(JSC::Scope::isValidStrictMode):
(JSC::Scope::shadowsArguments):
(JSC::Scope::copyCapturedVariablesToVector):
(JSC::Scope::saveFunctionInfo):
(JSC::Scope::restoreFunctionInfo):
(JSC::ScopeRef::ScopeRef):
(JSC::ScopeRef::operator->):
(JSC::ScopeRef::index):
(JSC::ScopeRef::hasContainingScope):
(JSC::ScopeRef::containingScope):
(JSC::Parser::AllowInOverride::AllowInOverride):
(JSC::Parser::AllowInOverride::~AllowInOverride):
(JSC::Parser::AutoPopScopeRef::AutoPopScopeRef):
(JSC::Parser::AutoPopScopeRef::~AutoPopScopeRef):
(JSC::Parser::AutoPopScopeRef::setPopped):
(JSC::Parser::currentScope):
(JSC::Parser::pushScope):
(JSC::Parser::popScopeInternal):
(JSC::Parser::popScope):
(JSC::Parser::declareVariable):
(JSC::Parser::declareWrite):
(JSC::Parser::findCachedFunctionInfo):
(JSC::Parser::isFunctionBodyNode):
(JSC::Parser::next):
(JSC::Parser::nextExpectIdentifier):
(JSC::Parser::nextTokenIsColon):
(JSC::Parser::consume):
(JSC::Parser::getToken):
(JSC::Parser::match):
(JSC::Parser::tokenStart):
(JSC::Parser::tokenLine):
(JSC::Parser::tokenEnd):
(JSC::Parser::getTokenName):
(JSC::Parser::updateErrorMessageSpecialCase):
(JSC::Parser::updateErrorMessage):
(JSC::Parser::updateErrorWithNameAndMessage):
(JSC::Parser::startLoop):
(JSC::Parser::endLoop):
(JSC::Parser::startSwitch):
(JSC::Parser::endSwitch):
(JSC::Parser::setStrictMode):
(JSC::Parser::strictMode):
(JSC::Parser::isValidStrictMode):
(JSC::Parser::declareParameter):
(JSC::Parser::breakIsValid):
(JSC::Parser::continueIsValid):
(JSC::Parser::pushLabel):
(JSC::Parser::popLabel):
(JSC::Parser::getLabel):
(JSC::Parser::autoSemiColon):
(JSC::Parser::canRecurse):
(JSC::Parser::lastTokenEnd):
(JSC::Parser::DepthManager::DepthManager):
(JSC::Parser::DepthManager::~DepthManager):
(JSC::Parser::parse):
(JSC::parse):
* parser/ParserTokens.h: Added.
(JSC::JSTokenInfo::JSTokenInfo):
* parser/SourceCode.h:
(JSC::SourceCode::subExpression):
* parser/SourceProviderCacheItem.h:
* parser/SyntaxChecker.h:
(JSC::SyntaxChecker::SyntaxChecker):
(JSC::SyntaxChecker::makeFunctionCallNode):
(JSC::SyntaxChecker::createCommaExpr):
(JSC::SyntaxChecker::makeAssignNode):
(JSC::SyntaxChecker::makePrefixNode):
(JSC::SyntaxChecker::makePostfixNode):
(JSC::SyntaxChecker::makeTypeOfNode):
(JSC::SyntaxChecker::makeDeleteNode):
(JSC::SyntaxChecker::makeNegateNode):
(JSC::SyntaxChecker::makeBitwiseNotNode):
(JSC::SyntaxChecker::createLogicalNot):
(JSC::SyntaxChecker::createUnaryPlus):
(JSC::SyntaxChecker::createVoid):
(JSC::SyntaxChecker::thisExpr):
(JSC::SyntaxChecker::createResolve):
(JSC::SyntaxChecker::createObjectLiteral):
(JSC::SyntaxChecker::createArray):
(JSC::SyntaxChecker::createNumberExpr):
(JSC::SyntaxChecker::createString):
(JSC::SyntaxChecker::createBoolean):
(JSC::SyntaxChecker::createNull):
(JSC::SyntaxChecker::createBracketAccess):
(JSC::SyntaxChecker::createDotAccess):
(JSC::SyntaxChecker::createRegExp):
(JSC::SyntaxChecker::createNewExpr):
(JSC::SyntaxChecker::createConditionalExpr):
(JSC::SyntaxChecker::createAssignResolve):
(JSC::SyntaxChecker::createFunctionExpr):
(JSC::SyntaxChecker::createFunctionBody):
(JSC::SyntaxChecker::createArguments):
(JSC::SyntaxChecker::createArgumentsList):
(JSC::SyntaxChecker::createProperty):
(JSC::SyntaxChecker::createPropertyList):
(JSC::SyntaxChecker::createFuncDeclStatement):
(JSC::SyntaxChecker::createBlockStatement):
(JSC::SyntaxChecker::createExprStatement):
(JSC::SyntaxChecker::createIfStatement):
(JSC::SyntaxChecker::createForLoop):
(JSC::SyntaxChecker::createForInLoop):
(JSC::SyntaxChecker::createEmptyStatement):
(JSC::SyntaxChecker::createVarStatement):
(JSC::SyntaxChecker::createReturnStatement):
(JSC::SyntaxChecker::createBreakStatement):
(JSC::SyntaxChecker::createContinueStatement):
(JSC::SyntaxChecker::createTryStatement):
(JSC::SyntaxChecker::createSwitchStatement):
(JSC::SyntaxChecker::createWhileStatement):
(JSC::SyntaxChecker::createWithStatement):
(JSC::SyntaxChecker::createDoWhileStatement):
(JSC::SyntaxChecker::createLabelStatement):
(JSC::SyntaxChecker::createThrowStatement):
(JSC::SyntaxChecker::createDebugger):
(JSC::SyntaxChecker::createConstStatement):
(JSC::SyntaxChecker::appendConstDecl):
(JSC::SyntaxChecker::createGetterOrSetterProperty):
(JSC::SyntaxChecker::combineCommaNodes):
(JSC::SyntaxChecker::operatorStackPop):
* runtime/Executable.cpp:
(JSC::EvalExecutable::compileInternal):
(JSC::ProgramExecutable::checkSyntax):
(JSC::ProgramExecutable::compileInternal):
(JSC::FunctionExecutable::produceCodeBlockFor):
(JSC::FunctionExecutable::fromGlobalCode):
* runtime/JSGlobalData.cpp:
(JSC::JSGlobalData::JSGlobalData):
(JSC::JSGlobalData::~JSGlobalData):
* runtime/JSGlobalData.h:
* runtime/LiteralParser.cpp:
(JSC::LiteralParser::tryJSONPParse):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@98887 268f45cc-cd09-0410-ab3c-d52691b4dbfc

26 files changed:
Source/JavaScriptCore/CMakeLists.txt
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/GNUmakefile.list.am
Source/JavaScriptCore/JavaScriptCore.gypi
Source/JavaScriptCore/JavaScriptCore.pro
Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj
Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp
Source/JavaScriptCore/parser/ASTBuilder.h
Source/JavaScriptCore/parser/JSParser.cpp [deleted file]
Source/JavaScriptCore/parser/Lexer.cpp
Source/JavaScriptCore/parser/Lexer.h
Source/JavaScriptCore/parser/NodeConstructors.h
Source/JavaScriptCore/parser/NodeInfo.h
Source/JavaScriptCore/parser/Nodes.cpp
Source/JavaScriptCore/parser/Nodes.h
Source/JavaScriptCore/parser/Parser.cpp
Source/JavaScriptCore/parser/Parser.h
Source/JavaScriptCore/parser/ParserTokens.h [moved from Source/JavaScriptCore/parser/JSParser.h with 93% similarity]
Source/JavaScriptCore/parser/SourceCode.h
Source/JavaScriptCore/parser/SourceProviderCacheItem.h
Source/JavaScriptCore/parser/SyntaxChecker.h
Source/JavaScriptCore/runtime/Executable.cpp
Source/JavaScriptCore/runtime/JSGlobalData.cpp
Source/JavaScriptCore/runtime/JSGlobalData.h
Source/JavaScriptCore/runtime/LiteralParser.cpp

index 452b123..9fb40d1 100644 (file)
@@ -77,7 +77,6 @@ SET(JavaScriptCore_SOURCES
     jit/JITStubs.cpp
     jit/ThunkGenerators.cpp
 
-    parser/JSParser.cpp
     parser/Lexer.cpp
     parser/Nodes.cpp
     parser/Parser.cpp
index 95a5fde..9747798 100644 (file)
@@ -1,3 +1,474 @@
+2011-10-31  Michael Saboff  <msaboff@apple.com>
+
+        Towards 8-bit Strings: Move Lexer and Parser Objects out of JSGlobalData
+        https://bugs.webkit.org/show_bug.cgi?id=71138
+
+        Restructure and movement of Lexer and Parser code.
+        Moved Lexer and Parser objects out of JSGlobalData.
+        Added a new ParserTokens class and instance to JSGlobalData that
+        have JavaScript token related definitions.
+        Replaced JSGlobalData arguments to Node classes with lineNumber,
+        as that was the only use of the JSGlobalData.
+        Combined JSParser and Parser classes into one class,
+        eliminating JSParser.h and .cpp.
+        Various supporting #include changes.
+
+        These mostly mechanical changes are done in preparation to
+        making the Lexer and Parser template classes.
+
+        Reviewed by Darin Adler.
+
+        * CMakeLists.txt:
+        * GNUmakefile.list.am:
+        * JavaScriptCore.gypi:
+        * JavaScriptCore.pro:
+        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
+        * JavaScriptCore.xcodeproj/project.pbxproj:
+        * bytecompiler/NodesCodegen.cpp:
+        (JSC::ArrayNode::toArgumentList):
+        (JSC::ApplyFunctionCallDotNode::emitBytecode):
+        * parser/ASTBuilder.h:
+        (JSC::ASTBuilder::ASTBuilder):
+        (JSC::ASTBuilder::createSourceElements):
+        (JSC::ASTBuilder::createCommaExpr):
+        (JSC::ASTBuilder::createLogicalNot):
+        (JSC::ASTBuilder::createUnaryPlus):
+        (JSC::ASTBuilder::createVoid):
+        (JSC::ASTBuilder::thisExpr):
+        (JSC::ASTBuilder::createResolve):
+        (JSC::ASTBuilder::createObjectLiteral):
+        (JSC::ASTBuilder::createArray):
+        (JSC::ASTBuilder::createNumberExpr):
+        (JSC::ASTBuilder::createString):
+        (JSC::ASTBuilder::createBoolean):
+        (JSC::ASTBuilder::createNull):
+        (JSC::ASTBuilder::createBracketAccess):
+        (JSC::ASTBuilder::createDotAccess):
+        (JSC::ASTBuilder::createRegExp):
+        (JSC::ASTBuilder::createNewExpr):
+        (JSC::ASTBuilder::createConditionalExpr):
+        (JSC::ASTBuilder::createAssignResolve):
+        (JSC::ASTBuilder::createFunctionExpr):
+        (JSC::ASTBuilder::createFunctionBody):
+        (JSC::ASTBuilder::createGetterOrSetterProperty):
+        (JSC::ASTBuilder::createArguments):
+        (JSC::ASTBuilder::createArgumentsList):
+        (JSC::ASTBuilder::createPropertyList):
+        (JSC::ASTBuilder::createElementList):
+        (JSC::ASTBuilder::createFormalParameterList):
+        (JSC::ASTBuilder::createClause):
+        (JSC::ASTBuilder::createClauseList):
+        (JSC::ASTBuilder::createFuncDeclStatement):
+        (JSC::ASTBuilder::createBlockStatement):
+        (JSC::ASTBuilder::createExprStatement):
+        (JSC::ASTBuilder::createIfStatement):
+        (JSC::ASTBuilder::createForLoop):
+        (JSC::ASTBuilder::createForInLoop):
+        (JSC::ASTBuilder::createEmptyStatement):
+        (JSC::ASTBuilder::createVarStatement):
+        (JSC::ASTBuilder::createReturnStatement):
+        (JSC::ASTBuilder::createBreakStatement):
+        (JSC::ASTBuilder::createContinueStatement):
+        (JSC::ASTBuilder::createTryStatement):
+        (JSC::ASTBuilder::createSwitchStatement):
+        (JSC::ASTBuilder::createWhileStatement):
+        (JSC::ASTBuilder::createDoWhileStatement):
+        (JSC::ASTBuilder::createLabelStatement):
+        (JSC::ASTBuilder::createWithStatement):
+        (JSC::ASTBuilder::createThrowStatement):
+        (JSC::ASTBuilder::createDebugger):
+        (JSC::ASTBuilder::createConstStatement):
+        (JSC::ASTBuilder::appendConstDecl):
+        (JSC::ASTBuilder::combineCommaNodes):
+        (JSC::ASTBuilder::appendBinaryOperation):
+        (JSC::ASTBuilder::createAssignment):
+        (JSC::ASTBuilder::createNumber):
+        (JSC::ASTBuilder::makeTypeOfNode):
+        (JSC::ASTBuilder::makeDeleteNode):
+        (JSC::ASTBuilder::makeNegateNode):
+        (JSC::ASTBuilder::makeBitwiseNotNode):
+        (JSC::ASTBuilder::makeMultNode):
+        (JSC::ASTBuilder::makeDivNode):
+        (JSC::ASTBuilder::makeModNode):
+        (JSC::ASTBuilder::makeAddNode):
+        (JSC::ASTBuilder::makeSubNode):
+        (JSC::ASTBuilder::makeLeftShiftNode):
+        (JSC::ASTBuilder::makeRightShiftNode):
+        (JSC::ASTBuilder::makeURightShiftNode):
+        (JSC::ASTBuilder::makeBitOrNode):
+        (JSC::ASTBuilder::makeBitAndNode):
+        (JSC::ASTBuilder::makeBitXOrNode):
+        (JSC::ASTBuilder::makeFunctionCallNode):
+        (JSC::ASTBuilder::makeBinaryNode):
+        (JSC::ASTBuilder::makeAssignNode):
+        (JSC::ASTBuilder::makePrefixNode):
+        (JSC::ASTBuilder::makePostfixNode):
+        * parser/JSParser.cpp: Removed.
+        * parser/JSParser.h: Removed.
+        * parser/Lexer.cpp:
+        (JSC::Keywords::Keywords):
+        (JSC::Lexer::Lexer):
+        (JSC::Lexer::~Lexer):
+        (JSC::Lexer::setCode):
+        (JSC::Lexer::parseIdentifier):
+        * parser/Lexer.h:
+        (JSC::Keywords::isKeyword):
+        (JSC::Keywords::getKeyword):
+        (JSC::Keywords::~Keywords):
+        (JSC::Lexer::setIsReparsing):
+        (JSC::Lexer::isReparsing):
+        (JSC::Lexer::lineNumber):
+        (JSC::Lexer::setLastLineNumber):
+        (JSC::Lexer::lastLineNumber):
+        (JSC::Lexer::prevTerminator):
+        (JSC::Lexer::sawError):
+        (JSC::Lexer::getErrorMessage):
+        (JSC::Lexer::currentOffset):
+        (JSC::Lexer::setOffset):
+        (JSC::Lexer::setLineNumber):
+        (JSC::Lexer::sourceProvider):
+        (JSC::Lexer::isWhiteSpace):
+        (JSC::Lexer::isLineTerminator):
+        (JSC::Lexer::convertHex):
+        (JSC::Lexer::convertUnicode):
+        (JSC::Lexer::makeIdentifier):
+        (JSC::Lexer::lexExpectIdentifier):
+        * parser/NodeConstructors.h:
+        (JSC::ParserArenaFreeable::operator new):
+        (JSC::ParserArenaDeletable::operator new):
+        (JSC::ParserArenaRefCounted::ParserArenaRefCounted):
+        (JSC::Node::Node):
+        (JSC::ExpressionNode::ExpressionNode):
+        (JSC::StatementNode::StatementNode):
+        (JSC::NullNode::NullNode):
+        (JSC::BooleanNode::BooleanNode):
+        (JSC::NumberNode::NumberNode):
+        (JSC::StringNode::StringNode):
+        (JSC::RegExpNode::RegExpNode):
+        (JSC::ThisNode::ThisNode):
+        (JSC::ResolveNode::ResolveNode):
+        (JSC::ElementNode::ElementNode):
+        (JSC::ArrayNode::ArrayNode):
+        (JSC::PropertyNode::PropertyNode):
+        (JSC::PropertyListNode::PropertyListNode):
+        (JSC::ObjectLiteralNode::ObjectLiteralNode):
+        (JSC::BracketAccessorNode::BracketAccessorNode):
+        (JSC::DotAccessorNode::DotAccessorNode):
+        (JSC::ArgumentListNode::ArgumentListNode):
+        (JSC::ArgumentsNode::ArgumentsNode):
+        (JSC::NewExprNode::NewExprNode):
+        (JSC::EvalFunctionCallNode::EvalFunctionCallNode):
+        (JSC::FunctionCallValueNode::FunctionCallValueNode):
+        (JSC::FunctionCallResolveNode::FunctionCallResolveNode):
+        (JSC::FunctionCallBracketNode::FunctionCallBracketNode):
+        (JSC::FunctionCallDotNode::FunctionCallDotNode):
+        (JSC::CallFunctionCallDotNode::CallFunctionCallDotNode):
+        (JSC::ApplyFunctionCallDotNode::ApplyFunctionCallDotNode):
+        (JSC::PrePostResolveNode::PrePostResolveNode):
+        (JSC::PostfixResolveNode::PostfixResolveNode):
+        (JSC::PostfixBracketNode::PostfixBracketNode):
+        (JSC::PostfixDotNode::PostfixDotNode):
+        (JSC::PostfixErrorNode::PostfixErrorNode):
+        (JSC::DeleteResolveNode::DeleteResolveNode):
+        (JSC::DeleteBracketNode::DeleteBracketNode):
+        (JSC::DeleteDotNode::DeleteDotNode):
+        (JSC::DeleteValueNode::DeleteValueNode):
+        (JSC::VoidNode::VoidNode):
+        (JSC::TypeOfResolveNode::TypeOfResolveNode):
+        (JSC::TypeOfValueNode::TypeOfValueNode):
+        (JSC::PrefixResolveNode::PrefixResolveNode):
+        (JSC::PrefixBracketNode::PrefixBracketNode):
+        (JSC::PrefixDotNode::PrefixDotNode):
+        (JSC::PrefixErrorNode::PrefixErrorNode):
+        (JSC::UnaryOpNode::UnaryOpNode):
+        (JSC::UnaryPlusNode::UnaryPlusNode):
+        (JSC::NegateNode::NegateNode):
+        (JSC::BitwiseNotNode::BitwiseNotNode):
+        (JSC::LogicalNotNode::LogicalNotNode):
+        (JSC::BinaryOpNode::BinaryOpNode):
+        (JSC::MultNode::MultNode):
+        (JSC::DivNode::DivNode):
+        (JSC::ModNode::ModNode):
+        (JSC::AddNode::AddNode):
+        (JSC::SubNode::SubNode):
+        (JSC::LeftShiftNode::LeftShiftNode):
+        (JSC::RightShiftNode::RightShiftNode):
+        (JSC::UnsignedRightShiftNode::UnsignedRightShiftNode):
+        (JSC::LessNode::LessNode):
+        (JSC::GreaterNode::GreaterNode):
+        (JSC::LessEqNode::LessEqNode):
+        (JSC::GreaterEqNode::GreaterEqNode):
+        (JSC::ThrowableBinaryOpNode::ThrowableBinaryOpNode):
+        (JSC::InstanceOfNode::InstanceOfNode):
+        (JSC::InNode::InNode):
+        (JSC::EqualNode::EqualNode):
+        (JSC::NotEqualNode::NotEqualNode):
+        (JSC::StrictEqualNode::StrictEqualNode):
+        (JSC::NotStrictEqualNode::NotStrictEqualNode):
+        (JSC::BitAndNode::BitAndNode):
+        (JSC::BitOrNode::BitOrNode):
+        (JSC::BitXOrNode::BitXOrNode):
+        (JSC::LogicalOpNode::LogicalOpNode):
+        (JSC::ConditionalNode::ConditionalNode):
+        (JSC::ReadModifyResolveNode::ReadModifyResolveNode):
+        (JSC::AssignResolveNode::AssignResolveNode):
+        (JSC::ReadModifyBracketNode::ReadModifyBracketNode):
+        (JSC::AssignBracketNode::AssignBracketNode):
+        (JSC::AssignDotNode::AssignDotNode):
+        (JSC::ReadModifyDotNode::ReadModifyDotNode):
+        (JSC::AssignErrorNode::AssignErrorNode):
+        (JSC::CommaNode::CommaNode):
+        (JSC::ConstStatementNode::ConstStatementNode):
+        (JSC::SourceElements::SourceElements):
+        (JSC::EmptyStatementNode::EmptyStatementNode):
+        (JSC::DebuggerStatementNode::DebuggerStatementNode):
+        (JSC::ExprStatementNode::ExprStatementNode):
+        (JSC::VarStatementNode::VarStatementNode):
+        (JSC::IfNode::IfNode):
+        (JSC::IfElseNode::IfElseNode):
+        (JSC::DoWhileNode::DoWhileNode):
+        (JSC::WhileNode::WhileNode):
+        (JSC::ForNode::ForNode):
+        (JSC::ContinueNode::ContinueNode):
+        (JSC::BreakNode::BreakNode):
+        (JSC::ReturnNode::ReturnNode):
+        (JSC::WithNode::WithNode):
+        (JSC::LabelNode::LabelNode):
+        (JSC::ThrowNode::ThrowNode):
+        (JSC::TryNode::TryNode):
+        (JSC::ParameterNode::ParameterNode):
+        (JSC::FuncExprNode::FuncExprNode):
+        (JSC::FuncDeclNode::FuncDeclNode):
+        (JSC::CaseClauseNode::CaseClauseNode):
+        (JSC::ClauseListNode::ClauseListNode):
+        (JSC::CaseBlockNode::CaseBlockNode):
+        (JSC::SwitchNode::SwitchNode):
+        (JSC::ConstDeclNode::ConstDeclNode):
+        (JSC::BlockNode::BlockNode):
+        (JSC::ForInNode::ForInNode):
+        * parser/NodeInfo.h:
+        * parser/Nodes.cpp:
+        (JSC::StatementNode::setLoc):
+        (JSC::ScopeNode::ScopeNode):
+        (JSC::ProgramNode::ProgramNode):
+        (JSC::ProgramNode::create):
+        (JSC::EvalNode::EvalNode):
+        (JSC::EvalNode::create):
+        (JSC::FunctionBodyNode::FunctionBodyNode):
+        (JSC::FunctionBodyNode::create):
+        * parser/Nodes.h:
+        (JSC::Node::lineNo):
+        * parser/Parser.cpp:
+        (JSC::Parser::Parser):
+        (JSC::Parser::~Parser):
+        (JSC::Parser::parseInner):
+        (JSC::Parser::allowAutomaticSemicolon):
+        (JSC::Parser::parseSourceElements):
+        (JSC::Parser::parseVarDeclaration):
+        (JSC::Parser::parseConstDeclaration):
+        (JSC::Parser::parseDoWhileStatement):
+        (JSC::Parser::parseWhileStatement):
+        (JSC::Parser::parseVarDeclarationList):
+        (JSC::Parser::parseConstDeclarationList):
+        (JSC::Parser::parseForStatement):
+        (JSC::Parser::parseBreakStatement):
+        (JSC::Parser::parseContinueStatement):
+        (JSC::Parser::parseReturnStatement):
+        (JSC::Parser::parseThrowStatement):
+        (JSC::Parser::parseWithStatement):
+        (JSC::Parser::parseSwitchStatement):
+        (JSC::Parser::parseSwitchClauses):
+        (JSC::Parser::parseSwitchDefaultClause):
+        (JSC::Parser::parseTryStatement):
+        (JSC::Parser::parseDebuggerStatement):
+        (JSC::Parser::parseBlockStatement):
+        (JSC::Parser::parseStatement):
+        (JSC::Parser::parseFormalParameters):
+        (JSC::Parser::parseFunctionBody):
+        (JSC::Parser::parseFunctionInfo):
+        (JSC::Parser::parseFunctionDeclaration):
+        (JSC::LabelInfo::LabelInfo):
+        (JSC::Parser::parseExpressionOrLabelStatement):
+        (JSC::Parser::parseExpressionStatement):
+        (JSC::Parser::parseIfStatement):
+        (JSC::Parser::parseExpression):
+        (JSC::Parser::parseAssignmentExpression):
+        (JSC::Parser::parseConditionalExpression):
+        (JSC::isUnaryOp):
+        (JSC::Parser::isBinaryOperator):
+        (JSC::Parser::parseBinaryExpression):
+        (JSC::Parser::parseProperty):
+        (JSC::Parser::parseObjectLiteral):
+        (JSC::Parser::parseStrictObjectLiteral):
+        (JSC::Parser::parseArrayLiteral):
+        (JSC::Parser::parsePrimaryExpression):
+        (JSC::Parser::parseArguments):
+        (JSC::Parser::parseMemberExpression):
+        (JSC::Parser::parseUnaryExpression):
+        * parser/Parser.h:
+        (JSC::isEvalNode):
+        (JSC::EvalNode):
+        (JSC::DepthManager::DepthManager):
+        (JSC::DepthManager::~DepthManager):
+        (JSC::ScopeLabelInfo::ScopeLabelInfo):
+        (JSC::Scope::Scope):
+        (JSC::Scope::startSwitch):
+        (JSC::Scope::endSwitch):
+        (JSC::Scope::startLoop):
+        (JSC::Scope::endLoop):
+        (JSC::Scope::inLoop):
+        (JSC::Scope::breakIsValid):
+        (JSC::Scope::continueIsValid):
+        (JSC::Scope::pushLabel):
+        (JSC::Scope::popLabel):
+        (JSC::Scope::getLabel):
+        (JSC::Scope::setIsFunction):
+        (JSC::Scope::isFunction):
+        (JSC::Scope::isFunctionBoundary):
+        (JSC::Scope::declareVariable):
+        (JSC::Scope::declareWrite):
+        (JSC::Scope::preventNewDecls):
+        (JSC::Scope::allowsNewDecls):
+        (JSC::Scope::declareParameter):
+        (JSC::Scope::useVariable):
+        (JSC::Scope::setNeedsFullActivation):
+        (JSC::Scope::collectFreeVariables):
+        (JSC::Scope::getUncapturedWrittenVariables):
+        (JSC::Scope::getCapturedVariables):
+        (JSC::Scope::setStrictMode):
+        (JSC::Scope::strictMode):
+        (JSC::Scope::isValidStrictMode):
+        (JSC::Scope::shadowsArguments):
+        (JSC::Scope::copyCapturedVariablesToVector):
+        (JSC::Scope::saveFunctionInfo):
+        (JSC::Scope::restoreFunctionInfo):
+        (JSC::ScopeRef::ScopeRef):
+        (JSC::ScopeRef::operator->):
+        (JSC::ScopeRef::index):
+        (JSC::ScopeRef::hasContainingScope):
+        (JSC::ScopeRef::containingScope):
+        (JSC::Parser::AllowInOverride::AllowInOverride):
+        (JSC::Parser::AllowInOverride::~AllowInOverride):
+        (JSC::Parser::AutoPopScopeRef::AutoPopScopeRef):
+        (JSC::Parser::AutoPopScopeRef::~AutoPopScopeRef):
+        (JSC::Parser::AutoPopScopeRef::setPopped):
+        (JSC::Parser::currentScope):
+        (JSC::Parser::pushScope):
+        (JSC::Parser::popScopeInternal):
+        (JSC::Parser::popScope):
+        (JSC::Parser::declareVariable):
+        (JSC::Parser::declareWrite):
+        (JSC::Parser::findCachedFunctionInfo):
+        (JSC::Parser::isFunctionBodyNode):
+        (JSC::Parser::next):
+        (JSC::Parser::nextExpectIdentifier):
+        (JSC::Parser::nextTokenIsColon):
+        (JSC::Parser::consume):
+        (JSC::Parser::getToken):
+        (JSC::Parser::match):
+        (JSC::Parser::tokenStart):
+        (JSC::Parser::tokenLine):
+        (JSC::Parser::tokenEnd):
+        (JSC::Parser::getTokenName):
+        (JSC::Parser::updateErrorMessageSpecialCase):
+        (JSC::Parser::updateErrorMessage):
+        (JSC::Parser::updateErrorWithNameAndMessage):
+        (JSC::Parser::startLoop):
+        (JSC::Parser::endLoop):
+        (JSC::Parser::startSwitch):
+        (JSC::Parser::endSwitch):
+        (JSC::Parser::setStrictMode):
+        (JSC::Parser::strictMode):
+        (JSC::Parser::isValidStrictMode):
+        (JSC::Parser::declareParameter):
+        (JSC::Parser::breakIsValid):
+        (JSC::Parser::continueIsValid):
+        (JSC::Parser::pushLabel):
+        (JSC::Parser::popLabel):
+        (JSC::Parser::getLabel):
+        (JSC::Parser::autoSemiColon):
+        (JSC::Parser::canRecurse):
+        (JSC::Parser::lastTokenEnd):
+        (JSC::Parser::DepthManager::DepthManager):
+        (JSC::Parser::DepthManager::~DepthManager):
+        (JSC::Parser::parse):
+        (JSC::parse):
+        * parser/ParserTokens.h: Added.
+        (JSC::JSTokenInfo::JSTokenInfo):
+        * parser/SourceCode.h:
+        (JSC::SourceCode::subExpression):
+        * parser/SourceProviderCacheItem.h:
+        * parser/SyntaxChecker.h:
+        (JSC::SyntaxChecker::SyntaxChecker):
+        (JSC::SyntaxChecker::makeFunctionCallNode):
+        (JSC::SyntaxChecker::createCommaExpr):
+        (JSC::SyntaxChecker::makeAssignNode):
+        (JSC::SyntaxChecker::makePrefixNode):
+        (JSC::SyntaxChecker::makePostfixNode):
+        (JSC::SyntaxChecker::makeTypeOfNode):
+        (JSC::SyntaxChecker::makeDeleteNode):
+        (JSC::SyntaxChecker::makeNegateNode):
+        (JSC::SyntaxChecker::makeBitwiseNotNode):
+        (JSC::SyntaxChecker::createLogicalNot):
+        (JSC::SyntaxChecker::createUnaryPlus):
+        (JSC::SyntaxChecker::createVoid):
+        (JSC::SyntaxChecker::thisExpr):
+        (JSC::SyntaxChecker::createResolve):
+        (JSC::SyntaxChecker::createObjectLiteral):
+        (JSC::SyntaxChecker::createArray):
+        (JSC::SyntaxChecker::createNumberExpr):
+        (JSC::SyntaxChecker::createString):
+        (JSC::SyntaxChecker::createBoolean):
+        (JSC::SyntaxChecker::createNull):
+        (JSC::SyntaxChecker::createBracketAccess):
+        (JSC::SyntaxChecker::createDotAccess):
+        (JSC::SyntaxChecker::createRegExp):
+        (JSC::SyntaxChecker::createNewExpr):
+        (JSC::SyntaxChecker::createConditionalExpr):
+        (JSC::SyntaxChecker::createAssignResolve):
+        (JSC::SyntaxChecker::createFunctionExpr):
+        (JSC::SyntaxChecker::createFunctionBody):
+        (JSC::SyntaxChecker::createArguments):
+        (JSC::SyntaxChecker::createArgumentsList):
+        (JSC::SyntaxChecker::createProperty):
+        (JSC::SyntaxChecker::createPropertyList):
+        (JSC::SyntaxChecker::createFuncDeclStatement):
+        (JSC::SyntaxChecker::createBlockStatement):
+        (JSC::SyntaxChecker::createExprStatement):
+        (JSC::SyntaxChecker::createIfStatement):
+        (JSC::SyntaxChecker::createForLoop):
+        (JSC::SyntaxChecker::createForInLoop):
+        (JSC::SyntaxChecker::createEmptyStatement):
+        (JSC::SyntaxChecker::createVarStatement):
+        (JSC::SyntaxChecker::createReturnStatement):
+        (JSC::SyntaxChecker::createBreakStatement):
+        (JSC::SyntaxChecker::createContinueStatement):
+        (JSC::SyntaxChecker::createTryStatement):
+        (JSC::SyntaxChecker::createSwitchStatement):
+        (JSC::SyntaxChecker::createWhileStatement):
+        (JSC::SyntaxChecker::createWithStatement):
+        (JSC::SyntaxChecker::createDoWhileStatement):
+        (JSC::SyntaxChecker::createLabelStatement):
+        (JSC::SyntaxChecker::createThrowStatement):
+        (JSC::SyntaxChecker::createDebugger):
+        (JSC::SyntaxChecker::createConstStatement):
+        (JSC::SyntaxChecker::appendConstDecl):
+        (JSC::SyntaxChecker::createGetterOrSetterProperty):
+        (JSC::SyntaxChecker::combineCommaNodes):
+        (JSC::SyntaxChecker::operatorStackPop):
+        * runtime/Executable.cpp:
+        (JSC::EvalExecutable::compileInternal):
+        (JSC::ProgramExecutable::checkSyntax):
+        (JSC::ProgramExecutable::compileInternal):
+        (JSC::FunctionExecutable::produceCodeBlockFor):
+        (JSC::FunctionExecutable::fromGlobalCode):
+        * runtime/JSGlobalData.cpp:
+        (JSC::JSGlobalData::JSGlobalData):
+        (JSC::JSGlobalData::~JSGlobalData):
+        * runtime/JSGlobalData.h:
+        * runtime/LiteralParser.cpp:
+        (JSC::LiteralParser::tryJSONPParse):
+
 2011-10-31  Filip Pizlo  <fpizlo@apple.com>
 
         REGRESSION (r97118): Reproducible crash in JSCell::toPrimitive when adding
index 8fd4ecb..a5799d5 100644 (file)
@@ -262,8 +262,6 @@ javascriptcore_sources += \
        Source/JavaScriptCore/os-win32/stdbool.h \
        Source/JavaScriptCore/os-win32/stdint.h \
        Source/JavaScriptCore/parser/ASTBuilder.h \
-       Source/JavaScriptCore/parser/JSParser.cpp \
-       Source/JavaScriptCore/parser/JSParser.h \
        Source/JavaScriptCore/parser/Lexer.cpp \
        Source/JavaScriptCore/parser/Lexer.h \
        Source/JavaScriptCore/parser/NodeConstructors.h \
index 36f418c..e211003 100644 (file)
             'os-win32/stdbool.h',
             'os-win32/stdint.h',
             'parser/ASTBuilder.h',
-            'parser/JSParser.cpp',
-            'parser/JSParser.h',
             'parser/Lexer.cpp',
             'parser/Lexer.h',
             'parser/NodeConstructors.h',
index 40daa7c..2644d1c 100644 (file)
@@ -110,7 +110,6 @@ SOURCES += \
     jit/JITPropertyAccess32_64.cpp \
     jit/JITStubs.cpp \
     jit/ThunkGenerators.cpp \
-    parser/JSParser.cpp \
     parser/Lexer.cpp \
     parser/Nodes.cpp \
     parser/ParserArena.cpp \
index 0159ad4..d81c4ac 100644 (file)
                                >
                        </File>
                        <File
-                               RelativePath="..\..\parser\JSParser.cpp"
-                               >
-                       </File>
-                       <File
-                               RelativePath="..\..\parser\JSParser.h"
-                               >
-                       </File>
-                       <File
                                RelativePath="..\..\parser\Lexer.cpp"
                                >
                        </File>
index 52d6587..2a3aa89 100644 (file)
                651122FE14046A4C002B101D /* libedit.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 5D5D8AD00E0D0EBE00F9C692 /* libedit.dylib */; };
                6511230714046B0A002B101D /* testRegExp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 651122E5140469BA002B101D /* testRegExp.cpp */; };
                651DCA04136A6FEF00F74194 /* PassTraits.h in Headers */ = {isa = PBXBuildFile; fileRef = 651DCA02136A6FAB00F74194 /* PassTraits.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               65303D641447B9E100D3F904 /* ParserTokens.h in Headers */ = {isa = PBXBuildFile; fileRef = 65303D631447B9E100D3F904 /* ParserTokens.h */; };
                655EB29B10CE2581001A990E /* NodesCodegen.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 655EB29A10CE2581001A990E /* NodesCodegen.cpp */; };
                65DFC93308EA173A00F7300B /* HashTable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 65DFC92D08EA173A00F7300B /* HashTable.cpp */; };
                65E1A3DF122B894500B26097 /* NonCopyingSort.h in Headers */ = {isa = PBXBuildFile; fileRef = 65E1A2F4122B880D00B26097 /* NonCopyingSort.h */; settings = {ATTRIBUTES = (Private, ); }; };
                A76F54A313B28AAB00EF2BCE /* JITWriteBarrier.h in Headers */ = {isa = PBXBuildFile; fileRef = A76F54A213B28AAB00EF2BCE /* JITWriteBarrier.h */; };
                A781E359141970C700094D90 /* StorageBarrier.h in Headers */ = {isa = PBXBuildFile; fileRef = A781E358141970C700094D90 /* StorageBarrier.h */; settings = {ATTRIBUTES = (Private, ); }; };
                A784A26111D16622005776AC /* ASTBuilder.h in Headers */ = {isa = PBXBuildFile; fileRef = A7A7EE7411B98B8D0065A14F /* ASTBuilder.h */; };
-               A784A26211D16622005776AC /* JSParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A7A7EE7511B98B8D0065A14F /* JSParser.cpp */; };
-               A784A26311D16622005776AC /* JSParser.h in Headers */ = {isa = PBXBuildFile; fileRef = A7A7EE7611B98B8D0065A14F /* JSParser.h */; };
                A784A26411D16622005776AC /* SyntaxChecker.h in Headers */ = {isa = PBXBuildFile; fileRef = A7A7EE7711B98B8D0065A14F /* SyntaxChecker.h */; };
                A791EF280F11E07900AE1F68 /* JSByteArray.h in Headers */ = {isa = PBXBuildFile; fileRef = A791EF260F11E07900AE1F68 /* JSByteArray.h */; settings = {ATTRIBUTES = (Private, ); }; };
                A791EF290F11E07900AE1F68 /* JSByteArray.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A791EF270F11E07900AE1F68 /* JSByteArray.cpp */; };
                651F6412039D5B5F0078395C /* dtoa.cpp */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.cpp.cpp; path = dtoa.cpp; sourceTree = "<group>"; tabWidth = 8; };
                651F6413039D5B5F0078395C /* dtoa.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = dtoa.h; sourceTree = "<group>"; tabWidth = 8; };
                652246A40C8D7A0E007BDAF7 /* HashIterators.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = HashIterators.h; sourceTree = "<group>"; };
+               65303D631447B9E100D3F904 /* ParserTokens.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParserTokens.h; sourceTree = "<group>"; };
                65400C0F0A69BAF200509887 /* PropertyNameArray.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = PropertyNameArray.cpp; sourceTree = "<group>"; };
                65400C100A69BAF200509887 /* PropertyNameArray.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = PropertyNameArray.h; sourceTree = "<group>"; };
                6541BD6E08E80A17002CBEE7 /* TCPageMap.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = TCPageMap.h; sourceTree = "<group>"; tabWidth = 8; };
                A7A1F7AA0F252B3C00E184E2 /* ByteArray.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ByteArray.cpp; sourceTree = "<group>"; };
                A7A1F7AB0F252B3C00E184E2 /* ByteArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ByteArray.h; sourceTree = "<group>"; };
                A7A7EE7411B98B8D0065A14F /* ASTBuilder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ASTBuilder.h; sourceTree = "<group>"; };
-               A7A7EE7511B98B8D0065A14F /* JSParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSParser.cpp; sourceTree = "<group>"; };
-               A7A7EE7611B98B8D0065A14F /* JSParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSParser.h; sourceTree = "<group>"; };
                A7A7EE7711B98B8D0065A14F /* SyntaxChecker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SyntaxChecker.h; sourceTree = "<group>"; };
                A7B48DB50EE74CFC00DCBDB6 /* ExecutableAllocator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ExecutableAllocator.h; sourceTree = "<group>"; };
                A7B48DB60EE74CFC00DCBDB6 /* ExecutableAllocator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ExecutableAllocator.cpp; sourceTree = "<group>"; };
                7E39D8370EC3A388003AF11A /* parser */ = {
                        isa = PBXGroup;
                        children = (
+                               65303D631447B9E100D3F904 /* ParserTokens.h */,
                                A7A7EE7411B98B8D0065A14F /* ASTBuilder.h */,
-                               A7A7EE7511B98B8D0065A14F /* JSParser.cpp */,
-                               A7A7EE7611B98B8D0065A14F /* JSParser.h */,
                                93F1981A08245AAE001E9ABC /* Keywords.table */,
                                F692A8650255597D01FF60F7 /* Lexer.cpp */,
                                F692A8660255597D01FF60F7 /* Lexer.h */,
                                A7280A2811557E3000D56957 /* JSObjectRefPrivate.h in Headers */,
                                A7F9935F0FD7325100A0B2D0 /* JSONObject.h in Headers */,
                                BC87CDB910712AD4000614CF /* JSONObject.lut.h in Headers */,
-                               A784A26311D16622005776AC /* JSParser.h in Headers */,
                                9534AAFB0E5B7A9600B8A45B /* JSProfilerPrivate.h in Headers */,
                                BC18C4260E16F5CD00B34460 /* JSRetainPtr.h in Headers */,
                                BC18C4270E16F5CD00B34460 /* JSString.h in Headers */,
                                0F620177143FCD3F0068B77C /* DFGAbstractValue.h in Headers */,
                                0F620178143FCD440068B77C /* DFGAbstractState.h in Headers */,
                                0FBD7E691447999600481315 /* CodeOrigin.h in Headers */,
+                               65303D641447B9E100D3F904 /* ParserTokens.h in Headers */,
                        );
                        runOnlyForDeploymentPostprocessing = 0;
                };
                                147F39D4107EC37600427A48 /* JSObject.cpp in Sources */,
                                1482B7E40A43076000517CFC /* JSObjectRef.cpp in Sources */,
                                A7F993600FD7325100A0B2D0 /* JSONObject.cpp in Sources */,
-                               A784A26211D16622005776AC /* JSParser.cpp in Sources */,
                                95F6E6950E5B5F970091E860 /* JSProfilerPrivate.cpp in Sources */,
                                A727FF6B0DA3092200E548D7 /* JSPropertyNameIterator.cpp in Sources */,
                                140566D1107EC267005DBC8D /* JSStaticScopeObject.cpp in Sources */,
index 1fc0bac..085f69d 100644 (file)
@@ -200,18 +200,18 @@ bool ArrayNode::isSimpleArray() const
     return true;
 }
 
-ArgumentListNode* ArrayNode::toArgumentList(JSGlobalData* globalData) const
+ArgumentListNode* ArrayNode::toArgumentList(JSGlobalData* globalData, int lineNumber) const
 {
     ASSERT(!m_elision && !m_optional);
     ElementNode* ptr = m_element;
     if (!ptr)
         return 0;
-    ArgumentListNode* head = new (globalData) ArgumentListNode(globalData, ptr->value());
+    ArgumentListNode* head = new (globalData) ArgumentListNode(lineNumber, ptr->value());
     ArgumentListNode* tail = head;
     ptr = ptr->next();
     for (; ptr; ptr = ptr->next()) {
         ASSERT(!ptr->elision());
-        tail = new (globalData) ArgumentListNode(globalData, tail, ptr->value());
+        tail = new (globalData) ArgumentListNode(lineNumber, tail, ptr->value());
     }
     return head;
 }
@@ -471,7 +471,7 @@ RegisterID* ApplyFunctionCallDotNode::emitBytecode(BytecodeGenerator& generator,
                 if (m_args->m_listNode->m_next) {
                     ASSERT(m_args->m_listNode->m_next->m_expr->isSimpleArray());
                     ASSERT(!m_args->m_listNode->m_next->m_next);
-                    m_args->m_listNode = static_cast<ArrayNode*>(m_args->m_listNode->m_next->m_expr)->toArgumentList(generator.globalData());
+                    m_args->m_listNode = static_cast<ArrayNode*>(m_args->m_listNode->m_next->m_expr)->toArgumentList(generator.globalData(), 0);
                     RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
                     CallArguments callArguments(generator, m_args);
                     generator.emitNode(callArguments.thisRegister(), oldList->m_expr);
index 8025c13..2e81c25 100644 (file)
@@ -73,9 +73,9 @@ class ASTBuilder {
         Operator m_op;
     };
 public:
-    ASTBuilder(JSGlobalData* globalData, Lexer* lexer)
+    ASTBuilder(JSGlobalData* globalData, SourceCode* sourceCode)
         : m_globalData(globalData)
-        , m_lexer(lexer)
+        , m_sourceCode(sourceCode)
         , m_scope(globalData)
         , m_evalCount(0)
     {
@@ -112,10 +112,10 @@ public:
     static const int  DontBuildKeywords = 0;
     static const int  DontBuildStrings = 0;
 
-    ExpressionNode* makeBinaryNode(int token, std::pair<ExpressionNode*, BinaryOpInfo>, std::pair<ExpressionNode*, BinaryOpInfo>);
-    ExpressionNode* makeFunctionCallNode(ExpressionNode* func, ArgumentsNode* args, int start, int divot, int end);
+    ExpressionNode* makeBinaryNode(int lineNumber, int token, std::pair<ExpressionNode*, BinaryOpInfo>, std::pair<ExpressionNode*, BinaryOpInfo>);
+    ExpressionNode* makeFunctionCallNode(int lineNumber, ExpressionNode* func, ArgumentsNode* args, int start, int divot, int end);
 
-    JSC::SourceElements* createSourceElements() { return new (m_globalData) JSC::SourceElements(m_globalData); }
+    JSC::SourceElements* createSourceElements() { return new (m_globalData) JSC::SourceElements(); }
 
     ParserArenaData<DeclarationStacks::VarStack>* varDeclarations() { return m_scope.m_varDeclarations; }
     ParserArenaData<DeclarationStacks::FunctionStack>* funcDeclarations() { return m_scope.m_funcDeclarations; }
@@ -124,182 +124,182 @@ public:
 
     void appendToComma(CommaNode* commaNode, ExpressionNode* expr) { commaNode->append(expr); }
 
-    CommaNode* createCommaExpr(ExpressionNode* lhs, ExpressionNode* rhs) { return new (m_globalData) CommaNode(m_globalData, lhs, rhs); }
-
-    ExpressionNode* makeAssignNode(ExpressionNode* left, Operator, ExpressionNode* right, bool leftHasAssignments, bool rightHasAssignments, int start, int divot, int end);
-    ExpressionNode* makePrefixNode(ExpressionNode*, Operator, int start, int divot, int end);
-    ExpressionNode* makePostfixNode(ExpressionNode*, Operator, int start, int divot, int end);
-    ExpressionNode* makeTypeOfNode(ExpressionNode*);
-    ExpressionNode* makeDeleteNode(ExpressionNode*, int start, int divot, int end);
-    ExpressionNode* makeNegateNode(ExpressionNode*);
-    ExpressionNode* makeBitwiseNotNode(ExpressionNode*);
-    ExpressionNode* makeMultNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
-    ExpressionNode* makeDivNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
-    ExpressionNode* makeModNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
-    ExpressionNode* makeAddNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
-    ExpressionNode* makeSubNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
-    ExpressionNode* makeBitXOrNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
-    ExpressionNode* makeBitAndNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
-    ExpressionNode* makeBitOrNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
-    ExpressionNode* makeLeftShiftNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
-    ExpressionNode* makeRightShiftNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
-    ExpressionNode* makeURightShiftNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
-
-    ExpressionNode* createLogicalNot(ExpressionNode* expr) { return new (m_globalData) LogicalNotNode(m_globalData, expr); }
-    ExpressionNode* createUnaryPlus(ExpressionNode* expr) { return new (m_globalData) UnaryPlusNode(m_globalData, expr); }
-    ExpressionNode* createVoid(ExpressionNode* expr)
+    CommaNode* createCommaExpr(int lineNumber, ExpressionNode* lhs, ExpressionNode* rhs) { return new (m_globalData) CommaNode(lineNumber, lhs, rhs); }
+
+    ExpressionNode* makeAssignNode(int lineNumber, ExpressionNode* left, Operator, ExpressionNode* right, bool leftHasAssignments, bool rightHasAssignments, int start, int divot, int end);
+    ExpressionNode* makePrefixNode(int lineNumber, ExpressionNode*, Operator, int start, int divot, int end);
+    ExpressionNode* makePostfixNode(int lineNumber, ExpressionNode*, Operator, int start, int divot, int end);
+    ExpressionNode* makeTypeOfNode(int lineNumber, ExpressionNode*);
+    ExpressionNode* makeDeleteNode(int lineNumber, ExpressionNode*, int start, int divot, int end);
+    ExpressionNode* makeNegateNode(int lineNumber, ExpressionNode*);
+    ExpressionNode* makeBitwiseNotNode(int lineNumber, ExpressionNode*);
+    ExpressionNode* makeMultNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
+    ExpressionNode* makeDivNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
+    ExpressionNode* makeModNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
+    ExpressionNode* makeAddNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
+    ExpressionNode* makeSubNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
+    ExpressionNode* makeBitXOrNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
+    ExpressionNode* makeBitAndNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
+    ExpressionNode* makeBitOrNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
+    ExpressionNode* makeLeftShiftNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
+    ExpressionNode* makeRightShiftNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
+    ExpressionNode* makeURightShiftNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
+
+    ExpressionNode* createLogicalNot(int lineNumber, ExpressionNode* expr) { return new (m_globalData) LogicalNotNode(lineNumber, expr); }
+    ExpressionNode* createUnaryPlus(int lineNumber, ExpressionNode* expr) { return new (m_globalData) UnaryPlusNode(lineNumber, expr); }
+    ExpressionNode* createVoid(int lineNumber, ExpressionNode* expr)
     {
         incConstants();
-        return new (m_globalData) VoidNode(m_globalData, expr);
+        return new (m_globalData) VoidNode(lineNumber, expr);
     }
-    ExpressionNode* thisExpr()
+    ExpressionNode* thisExpr(int lineNumber)
     {
         usesThis();
-        return new (m_globalData) ThisNode(m_globalData);
+        return new (m_globalData) ThisNode(lineNumber);
     }
-    ExpressionNode* createResolve(const Identifier* ident, int start)
+    ExpressionNode* createResolve(int lineNumber, const Identifier* ident, int start)
     {
         if (m_globalData->propertyNames->arguments == *ident)
             usesArguments();
-        return new (m_globalData) ResolveNode(m_globalData, *ident, start);
+        return new (m_globalData) ResolveNode(lineNumber, *ident, start);
     }
-    ExpressionNode* createObjectLiteral() { return new (m_globalData) ObjectLiteralNode(m_globalData); }
-    ExpressionNode* createObjectLiteral(PropertyListNode* properties) { return new (m_globalData) ObjectLiteralNode(m_globalData, properties); }
+    ExpressionNode* createObjectLiteral(int lineNumber) { return new (m_globalData) ObjectLiteralNode(lineNumber); }
+    ExpressionNode* createObjectLiteral(int lineNumber, PropertyListNode* properties) { return new (m_globalData) ObjectLiteralNode(lineNumber, properties); }
 
-    ExpressionNode* createArray(int elisions)
+    ExpressionNode* createArray(int lineNumber, int elisions)
     {
         if (elisions)
             incConstants();
-        return new (m_globalData) ArrayNode(m_globalData, elisions);
+        return new (m_globalData) ArrayNode(lineNumber, elisions);
     }
 
-    ExpressionNode* createArray(ElementNode* elems) { return new (m_globalData) ArrayNode(m_globalData, elems); }
-    ExpressionNode* createArray(int elisions, ElementNode* elems)
+    ExpressionNode* createArray(int lineNumber, ElementNode* elems) { return new (m_globalData) ArrayNode(lineNumber, elems); }
+    ExpressionNode* createArray(int lineNumber, int elisions, ElementNode* elems)
     {
         if (elisions)
             incConstants();
-        return new (m_globalData) ArrayNode(m_globalData, elisions, elems);
+        return new (m_globalData) ArrayNode(lineNumber, elisions, elems);
     }
-    ExpressionNode* createNumberExpr(double d)
+    ExpressionNode* createNumberExpr(int lineNumber, double d)
     {
         incConstants();
-        return new (m_globalData) NumberNode(m_globalData, d);
+        return new (m_globalData) NumberNode(lineNumber, d);
     }
 
-    ExpressionNode* createString(const Identifier* string)
+    ExpressionNode* createString(int lineNumber, const Identifier* string)
     {
         incConstants();
-        return new (m_globalData) StringNode(m_globalData, *string);
+        return new (m_globalData) StringNode(lineNumber, *string);
     }
 
-    ExpressionNode* createBoolean(bool b)
+    ExpressionNode* createBoolean(int lineNumber, bool b)
     {
         incConstants();
-        return new (m_globalData) BooleanNode(m_globalData, b);
+        return new (m_globalData) BooleanNode(lineNumber, b);
     }
 
-    ExpressionNode* createNull()
+    ExpressionNode* createNull(int lineNumber)
     {
         incConstants();
-        return new (m_globalData) NullNode(m_globalData);
+        return new (m_globalData) NullNode(lineNumber);
     }
 
-    ExpressionNode* createBracketAccess(ExpressionNode* base, ExpressionNode* property, bool propertyHasAssignments, int start, int divot, int end)
+    ExpressionNode* createBracketAccess(int lineNumber, ExpressionNode* base, ExpressionNode* property, bool propertyHasAssignments, int start, int divot, int end)
     {
-        BracketAccessorNode* node = new (m_globalData) BracketAccessorNode(m_globalData, base, property, propertyHasAssignments);
+        BracketAccessorNode* node = new (m_globalData) BracketAccessorNode(lineNumber, base, property, propertyHasAssignments);
         setExceptionLocation(node, start, divot, end);
         return node;
     }
 
-    ExpressionNode* createDotAccess(ExpressionNode* base, const Identifier* property, int start, int divot, int end)
+    ExpressionNode* createDotAccess(int lineNumber, ExpressionNode* base, const Identifier* property, int start, int divot, int end)
     {
-        DotAccessorNode* node = new (m_globalData) DotAccessorNode(m_globalData, base, *property);
+        DotAccessorNode* node = new (m_globalData) DotAccessorNode(lineNumber, base, *property);
         setExceptionLocation(node, start, divot, end);
         return node;
     }
 
-    ExpressionNode* createRegExp(const Identifier& pattern, const Identifier& flags, int start)
+    ExpressionNode* createRegExp(int lineNumber, const Identifier& pattern, const Identifier& flags, int start)
     {
         if (Yarr::checkSyntax(pattern.ustring()))
             return 0;
-        RegExpNode* node = new (m_globalData) RegExpNode(m_globalData, pattern, flags);
+        RegExpNode* node = new (m_globalData) RegExpNode(lineNumber, pattern, flags);
         int size = pattern.length() + 2; // + 2 for the two /'s
         setExceptionLocation(node, start, start + size, start + size);
         return node;
     }
 
-    ExpressionNode* createNewExpr(ExpressionNode* expr, ArgumentsNode* arguments, int start, int divot, int end)
+    ExpressionNode* createNewExpr(int lineNumber, ExpressionNode* expr, ArgumentsNode* arguments, int start, int divot, int end)
     {
-        NewExprNode* node = new (m_globalData) NewExprNode(m_globalData, expr, arguments);
+        NewExprNode* node = new (m_globalData) NewExprNode(lineNumber, expr, arguments);
         setExceptionLocation(node, start, divot, end);
         return node;
     }
 
-    ExpressionNode* createNewExpr(ExpressionNode* expr, int start, int end)
+    ExpressionNode* createNewExpr(int lineNumber, ExpressionNode* expr, int start, int end)
     {
-        NewExprNode* node = new (m_globalData) NewExprNode(m_globalData, expr);
+        NewExprNode* node = new (m_globalData) NewExprNode(lineNumber, expr);
         setExceptionLocation(node, start, end, end);
         return node;
     }
 
-    ExpressionNode* createConditionalExpr(ExpressionNode* condition, ExpressionNode* lhs, ExpressionNode* rhs)
+    ExpressionNode* createConditionalExpr(int lineNumber, ExpressionNode* condition, ExpressionNode* lhs, ExpressionNode* rhs)
     {
-        return new (m_globalData) ConditionalNode(m_globalData, condition, lhs, rhs);
+        return new (m_globalData) ConditionalNode(lineNumber, condition, lhs, rhs);
     }
 
-    ExpressionNode* createAssignResolve(const Identifier& ident, ExpressionNode* rhs, bool rhsHasAssignment, int start, int divot, int end)
+    ExpressionNode* createAssignResolve(int lineNumber, const Identifier& ident, ExpressionNode* rhs, bool rhsHasAssignment, int start, int divot, int end)
     {
-        AssignResolveNode* node = new (m_globalData) AssignResolveNode(m_globalData, ident, rhs, rhsHasAssignment);
+        AssignResolveNode* node = new (m_globalData) AssignResolveNode(lineNumber, ident, rhs, rhsHasAssignment);
         setExceptionLocation(node, start, divot, end);
         return node;
     }
 
-    ExpressionNode* createFunctionExpr(const Identifier* name, FunctionBodyNode* body, ParameterNode* parameters, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
+    ExpressionNode* createFunctionExpr(int lineNumber, const Identifier* name, FunctionBodyNode* body, ParameterNode* parameters, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
     {
-        FuncExprNode* result = new (m_globalData) FuncExprNode(m_globalData, *name, body, m_lexer->sourceCode(openBracePos, closeBracePos, bodyStartLine), parameters);
+        FuncExprNode* result = new (m_globalData) FuncExprNode(lineNumber, *name, body, m_sourceCode->subExpression(openBracePos, closeBracePos, bodyStartLine), parameters);
         body->setLoc(bodyStartLine, bodyEndLine);
         return result;
     }
 
-    FunctionBodyNode* createFunctionBody(bool inStrictContext)
+    FunctionBodyNode* createFunctionBody(int lineNumber, bool inStrictContext)
     {
         usesClosures();
-        return FunctionBodyNode::create(m_globalData, inStrictContext);
+        return FunctionBodyNode::create(m_globalData, lineNumber, inStrictContext);
     }
     
-    template <bool> PropertyNode* createGetterOrSetterProperty(PropertyNode::Type type, const Identifier* name, ParameterNode* params, FunctionBodyNode* body, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
+    template <bool> PropertyNode* createGetterOrSetterProperty(int lineNumber, PropertyNode::Type type, const Identifier* name, ParameterNode* params, FunctionBodyNode* body, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
     {
         ASSERT(name);
         body->setLoc(bodyStartLine, bodyEndLine);
-        return new (m_globalData) PropertyNode(m_globalData, *name, new (m_globalData) FuncExprNode(m_globalData, m_globalData->propertyNames->nullIdentifier, body, m_lexer->sourceCode(openBracePos, closeBracePos, bodyStartLine), params), type);
+        return new (m_globalData) PropertyNode(m_globalData, *name, new (m_globalData) FuncExprNode(lineNumber, m_globalData->propertyNames->nullIdentifier, body, m_sourceCode->subExpression(openBracePos, closeBracePos, bodyStartLine), params), type);
     }
     
 
-    ArgumentsNode* createArguments() { return new (m_globalData) ArgumentsNode(m_globalData); }
-    ArgumentsNode* createArguments(ArgumentListNode* args) { return new (m_globalData) ArgumentsNode(m_globalData, args); }
-    ArgumentListNode* createArgumentsList(ExpressionNode* arg) { return new (m_globalData) ArgumentListNode(m_globalData, arg); }
-    ArgumentListNode* createArgumentsList(ArgumentListNode* args, ExpressionNode* arg) { return new (m_globalData) ArgumentListNode(m_globalData, args, arg); }
+    ArgumentsNode* createArguments() { return new (m_globalData) ArgumentsNode(); }
+    ArgumentsNode* createArguments(ArgumentListNode* args) { return new (m_globalData) ArgumentsNode(args); }
+    ArgumentListNode* createArgumentsList(int lineNumber, ExpressionNode* arg) { return new (m_globalData) ArgumentListNode(lineNumber, arg); }
+    ArgumentListNode* createArgumentsList(int lineNumber, ArgumentListNode* args, ExpressionNode* arg) { return new (m_globalData) ArgumentListNode(lineNumber, args, arg); }
 
     template <bool> PropertyNode* createProperty(const Identifier* propertyName, ExpressionNode* node, PropertyNode::Type type) { return new (m_globalData) PropertyNode(m_globalData, *propertyName, node, type); }
     template <bool> PropertyNode* createProperty(JSGlobalData*, double propertyName, ExpressionNode* node, PropertyNode::Type type) { return new (m_globalData) PropertyNode(m_globalData, propertyName, node, type); }
-    PropertyListNode* createPropertyList(PropertyNode* property) { return new (m_globalData) PropertyListNode(m_globalData, property); }
-    PropertyListNode* createPropertyList(PropertyNode* property, PropertyListNode* tail) { return new (m_globalData) PropertyListNode(m_globalData, property, tail); }
+    PropertyListNode* createPropertyList(int lineNumber, PropertyNode* property) { return new (m_globalData) PropertyListNode(lineNumber, property); }
+    PropertyListNode* createPropertyList(int lineNumber, PropertyNode* property, PropertyListNode* tail) { return new (m_globalData) PropertyListNode(lineNumber, property, tail); }
 
-    ElementNode* createElementList(int elisions, ExpressionNode* expr) { return new (m_globalData) ElementNode(m_globalData, elisions, expr); }
-    ElementNode* createElementList(ElementNode* elems, int elisions, ExpressionNode* expr) { return new (m_globalData) ElementNode(m_globalData, elems, elisions, expr); }
+    ElementNode* createElementList(int elisions, ExpressionNode* expr) { return new (m_globalData) ElementNode(elisions, expr); }
+    ElementNode* createElementList(ElementNode* elems, int elisions, ExpressionNode* expr) { return new (m_globalData) ElementNode(elems, elisions, expr); }
 
-    ParameterNode* createFormalParameterList(const Identifier& ident) { return new (m_globalData) ParameterNode(m_globalData, ident); }
-    ParameterNode* createFormalParameterList(ParameterNode* list, const Identifier& ident) { return new (m_globalData) ParameterNode(m_globalData, list, ident); }
+    ParameterNode* createFormalParameterList(const Identifier& ident) { return new (m_globalData) ParameterNode(ident); }
+    ParameterNode* createFormalParameterList(ParameterNode* list, const Identifier& ident) { return new (m_globalData) ParameterNode(list, ident); }
 
-    CaseClauseNode* createClause(ExpressionNode* expr, JSC::SourceElements* statements) { return new (m_globalData) CaseClauseNode(m_globalData, expr, statements); }
-    ClauseListNode* createClauseList(CaseClauseNode* clause) { return new (m_globalData) ClauseListNode(m_globalData, clause); }
-    ClauseListNode* createClauseList(ClauseListNode* tail, CaseClauseNode* clause) { return new (m_globalData) ClauseListNode(m_globalData, tail, clause); }
+    CaseClauseNode* createClause(ExpressionNode* expr, JSC::SourceElements* statements) { return new (m_globalData) CaseClauseNode(expr, statements); }
+    ClauseListNode* createClauseList(CaseClauseNode* clause) { return new (m_globalData) ClauseListNode(clause); }
+    ClauseListNode* createClauseList(ClauseListNode* tail, CaseClauseNode* clause) { return new (m_globalData) ClauseListNode(tail, clause); }
 
     void setUsesArguments(FunctionBodyNode* node) { node->setUsesArguments(); }
 
-    StatementNode* createFuncDeclStatement(const Identifier* name, FunctionBodyNode* body, ParameterNode* parameters, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
+    StatementNode* createFuncDeclStatement(int lineNumber, const Identifier* name, FunctionBodyNode* body, ParameterNode* parameters, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
     {
-        FuncDeclNode* decl = new (m_globalData) FuncDeclNode(m_globalData, *name, body, m_lexer->sourceCode(openBracePos, closeBracePos, bodyStartLine), parameters);
+        FuncDeclNode* decl = new (m_globalData) FuncDeclNode(lineNumber, *name, body, m_sourceCode->subExpression(openBracePos, closeBracePos, bodyStartLine), parameters);
         if (*name == m_globalData->propertyNames->arguments)
             usesArguments();
         m_scope.m_funcDeclarations->data.append(decl->body());
@@ -307,181 +307,181 @@ public:
         return decl;
     }
 
-    StatementNode* createBlockStatement(JSC::SourceElements* elements, int startLine, int endLine)
+    StatementNode* createBlockStatement(int lineNumber, JSC::SourceElements* elements, int startLine, int endLine)
     {
-        BlockNode* block = new (m_globalData) BlockNode(m_globalData, elements);
+        BlockNode* block = new (m_globalData) BlockNode(lineNumber, elements);
         block->setLoc(startLine, endLine);
         return block;
     }
 
-    StatementNode* createExprStatement(ExpressionNode* expr, int start, int end)
+    StatementNode* createExprStatement(int lineNumber, ExpressionNode* expr, int start, int end)
     {
-        ExprStatementNode* result = new (m_globalData) ExprStatementNode(m_globalData, expr);
+        ExprStatementNode* result = new (m_globalData) ExprStatementNode(lineNumber, expr);
         result->setLoc(start, end);
         return result;
     }
 
-    StatementNode* createIfStatement(ExpressionNode* condition, StatementNode* trueBlock, int start, int end)
+    StatementNode* createIfStatement(int lineNumber, ExpressionNode* condition, StatementNode* trueBlock, int start, int end)
     {
-        IfNode* result = new (m_globalData) IfNode(m_globalData, condition, trueBlock);
+        IfNode* result = new (m_globalData) IfNode(lineNumber, condition, trueBlock);
         result->setLoc(start, end);
         return result;
     }
 
-    StatementNode* createIfStatement(ExpressionNode* condition, StatementNode* trueBlock, StatementNode* falseBlock, int start, int end)
+    StatementNode* createIfStatement(int lineNumber, ExpressionNode* condition, StatementNode* trueBlock, StatementNode* falseBlock, int start, int end)
     {
-        IfNode* result = new (m_globalData) IfElseNode(m_globalData, condition, trueBlock, falseBlock);
+        IfNode* result = new (m_globalData) IfElseNode(lineNumber, condition, trueBlock, falseBlock);
         result->setLoc(start, end);
         return result;
     }
 
-    StatementNode* createForLoop(ExpressionNode* initializer, ExpressionNode* condition, ExpressionNode* iter, StatementNode* statements, bool b, int start, int end)
+    StatementNode* createForLoop(int lineNumber, ExpressionNode* initializer, ExpressionNode* condition, ExpressionNode* iter, StatementNode* statements, bool b, int start, int end)
     {
-        ForNode* result = new (m_globalData) ForNode(m_globalData, initializer, condition, iter, statements, b);
+        ForNode* result = new (m_globalData) ForNode(lineNumber, initializer, condition, iter, statements, b);
         result->setLoc(start, end);
         return result;
     }
 
-    StatementNode* createForInLoop(const Identifier* ident, ExpressionNode* initializer, ExpressionNode* iter, StatementNode* statements, int start, int divot, int end, int initStart, int initEnd, int startLine, int endLine)
+    StatementNode* createForInLoop(int lineNumber, const Identifier* ident, ExpressionNode* initializer, ExpressionNode* iter, StatementNode* statements, int start, int divot, int end, int initStart, int initEnd, int startLine, int endLine)
     {
-        ForInNode* result = new (m_globalData) ForInNode(m_globalData, *ident, initializer, iter, statements, initStart, initStart - start, initEnd - initStart);
+        ForInNode* result = new (m_globalData) ForInNode(m_globalData, lineNumber, *ident, initializer, iter, statements, initStart, initStart - start, initEnd - initStart);
         result->setLoc(startLine, endLine);
         setExceptionLocation(result, start, divot + 1, end);
         return result;
     }
 
-    StatementNode* createForInLoop(ExpressionNode* lhs, ExpressionNode* iter, StatementNode* statements, int eStart, int eDivot, int eEnd, int start, int end)
+    StatementNode* createForInLoop(int lineNumber, ExpressionNode* lhs, ExpressionNode* iter, StatementNode* statements, int eStart, int eDivot, int eEnd, int start, int end)
     {
-        ForInNode* result = new (m_globalData) ForInNode(m_globalData, lhs, iter, statements);
+        ForInNode* result = new (m_globalData) ForInNode(m_globalData, lineNumber, lhs, iter, statements);
         result->setLoc(start, end);
         setExceptionLocation(result, eStart, eDivot, eEnd);
         return result;
     }
 
-    StatementNode* createEmptyStatement() { return new (m_globalData) EmptyStatementNode(m_globalData); }
+    StatementNode* createEmptyStatement(int lineNumber) { return new (m_globalData) EmptyStatementNode(lineNumber); }
 
-    StatementNode* createVarStatement(ExpressionNode* expr, int start, int end)
+    StatementNode* createVarStatement(int lineNumber, ExpressionNode* expr, int start, int end)
     {
         StatementNode* result;
         if (!expr)
-            result = new (m_globalData) EmptyStatementNode(m_globalData);
+            result = new (m_globalData) EmptyStatementNode(lineNumber);
         else
-            result = new (m_globalData) VarStatementNode(m_globalData, expr);
+            result = new (m_globalData) VarStatementNode(lineNumber, expr);
         result->setLoc(start, end);
         return result;
     }
 
-    StatementNode* createReturnStatement(ExpressionNode* expression, int eStart, int eEnd, int startLine, int endLine)
+    StatementNode* createReturnStatement(int lineNumber, ExpressionNode* expression, int eStart, int eEnd, int startLine, int endLine)
     {
-        ReturnNode* result = new (m_globalData) ReturnNode(m_globalData, expression);
+        ReturnNode* result = new (m_globalData) ReturnNode(lineNumber, expression);
         setExceptionLocation(result, eStart, eEnd, eEnd);
         result->setLoc(startLine, endLine);
         return result;
     }
 
-    StatementNode* createBreakStatement(int eStart, int eEnd, int startLine, int endLine)
+    StatementNode* createBreakStatement(int lineNumber, int eStart, int eEnd, int startLine, int endLine)
     {
-        BreakNode* result = new (m_globalData) BreakNode(m_globalData);
+        BreakNode* result = new (m_globalData) BreakNode(m_globalData, lineNumber);
         setExceptionLocation(result, eStart, eEnd, eEnd);
         result->setLoc(startLine, endLine);
         return result;
     }
 
-    StatementNode* createBreakStatement(const Identifier* ident, int eStart, int eEnd, int startLine, int endLine)
+    StatementNode* createBreakStatement(int lineNumber, const Identifier* ident, int eStart, int eEnd, int startLine, int endLine)
     {
-        BreakNode* result = new (m_globalData) BreakNode(m_globalData, *ident);
+        BreakNode* result = new (m_globalData) BreakNode(lineNumber, *ident);
         setExceptionLocation(result, eStart, eEnd, eEnd);
         result->setLoc(startLine, endLine);
         return result;
     }
 
-    StatementNode* createContinueStatement(int eStart, int eEnd, int startLine, int endLine)
+    StatementNode* createContinueStatement(int lineNumber, int eStart, int eEnd, int startLine, int endLine)
     {
-        ContinueNode* result = new (m_globalData) ContinueNode(m_globalData);
+        ContinueNode* result = new (m_globalData) ContinueNode(m_globalData, lineNumber);
         setExceptionLocation(result, eStart, eEnd, eEnd);
         result->setLoc(startLine, endLine);
         return result;
     }
 
-    StatementNode* createContinueStatement(const Identifier* ident, int eStart, int eEnd, int startLine, int endLine)
+    StatementNode* createContinueStatement(int lineNumber, const Identifier* ident, int eStart, int eEnd, int startLine, int endLine)
     {
-        ContinueNode* result = new (m_globalData) ContinueNode(m_globalData, *ident);
+        ContinueNode* result = new (m_globalData) ContinueNode(lineNumber, *ident);
         setExceptionLocation(result, eStart, eEnd, eEnd);
         result->setLoc(startLine, endLine);
         return result;
     }
 
-    StatementNode* createTryStatement(StatementNode* tryBlock, const Identifier* ident, bool catchHasEval, StatementNode* catchBlock, StatementNode* finallyBlock, int startLine, int endLine)
+    StatementNode* createTryStatement(int lineNumber, StatementNode* tryBlock, const Identifier* ident, bool catchHasEval, StatementNode* catchBlock, StatementNode* finallyBlock, int startLine, int endLine)
     {
-        TryNode* result = new (m_globalData) TryNode(m_globalData, tryBlock, *ident, catchHasEval, catchBlock, finallyBlock);
+        TryNode* result = new (m_globalData) TryNode(lineNumber, tryBlock, *ident, catchHasEval, catchBlock, finallyBlock);
         if (catchBlock)
             usesCatch();
         result->setLoc(startLine, endLine);
         return result;
     }
 
-    StatementNode* createSwitchStatement(ExpressionNode* expr, ClauseListNode* firstClauses, CaseClauseNode* defaultClause, ClauseListNode* secondClauses, int startLine, int endLine)
+    StatementNode* createSwitchStatement(int lineNumber, ExpressionNode* expr, ClauseListNode* firstClauses, CaseClauseNode* defaultClause, ClauseListNode* secondClauses, int startLine, int endLine)
     {
-        CaseBlockNode* cases = new (m_globalData) CaseBlockNode(m_globalData, firstClauses, defaultClause, secondClauses);
-        SwitchNode* result = new (m_globalData) SwitchNode(m_globalData, expr, cases);
+        CaseBlockNode* cases = new (m_globalData) CaseBlockNode(firstClauses, defaultClause, secondClauses);
+        SwitchNode* result = new (m_globalData) SwitchNode(lineNumber, expr, cases);
         result->setLoc(startLine, endLine);
         return result;
     }
 
-    StatementNode* createWhileStatement(ExpressionNode* expr, StatementNode* statement, int startLine, int endLine)
+    StatementNode* createWhileStatement(int lineNumber, ExpressionNode* expr, StatementNode* statement, int startLine, int endLine)
     {
-        WhileNode* result = new (m_globalData) WhileNode(m_globalData, expr, statement);
+        WhileNode* result = new (m_globalData) WhileNode(lineNumber, expr, statement);
         result->setLoc(startLine, endLine);
         return result;
     }
 
-    StatementNode* createDoWhileStatement(StatementNode* statement, ExpressionNode* expr, int startLine, int endLine)
+    StatementNode* createDoWhileStatement(int lineNumber, StatementNode* statement, ExpressionNode* expr, int startLine, int endLine)
     {
-        DoWhileNode* result = new (m_globalData) DoWhileNode(m_globalData, statement, expr);
+        DoWhileNode* result = new (m_globalData) DoWhileNode(lineNumber, statement, expr);
         result->setLoc(startLine, endLine);
         return result;
     }
 
-    StatementNode* createLabelStatement(const Identifier* ident, StatementNode* statement, int start, int end)
+    StatementNode* createLabelStatement(int lineNumber, const Identifier* ident, StatementNode* statement, int start, int end)
     {
-        LabelNode* result = new (m_globalData) LabelNode(m_globalData, *ident, statement);
+        LabelNode* result = new (m_globalData) LabelNode(lineNumber, *ident, statement);
         setExceptionLocation(result, start, end, end);
         return result;
     }
 
-    StatementNode* createWithStatement(ExpressionNode* expr, StatementNode* statement, int start, int end, int startLine, int endLine)
+    StatementNode* createWithStatement(int lineNumber, ExpressionNode* expr, StatementNode* statement, int start, int end, int startLine, int endLine)
     {
         usesWith();
-        WithNode* result = new (m_globalData) WithNode(m_globalData, expr, statement, end, end - start);
+        WithNode* result = new (m_globalData) WithNode(lineNumber, expr, statement, end, end - start);
         result->setLoc(startLine, endLine);
         return result;
     }    
     
-    StatementNode* createThrowStatement(ExpressionNode* expr, int start, int end, int startLine, int endLine)
+    StatementNode* createThrowStatement(int lineNumber, ExpressionNode* expr, int start, int end, int startLine, int endLine)
     {
-        ThrowNode* result = new (m_globalData) ThrowNode(m_globalData, expr);
+        ThrowNode* result = new (m_globalData) ThrowNode(lineNumber, expr);
         result->setLoc(startLine, endLine);
         setExceptionLocation(result, start, end, end);
         return result;
     }
     
-    StatementNode* createDebugger(int startLine, int endLine)
+    StatementNode* createDebugger(int lineNumber, int startLine, int endLine)
     {
-        DebuggerStatementNode* result = new (m_globalData) DebuggerStatementNode(m_globalData);
+        DebuggerStatementNode* result = new (m_globalData) DebuggerStatementNode(lineNumber);
         result->setLoc(startLine, endLine);
         return result;
     }
     
-    StatementNode* createConstStatement(ConstDeclNode* decls, int startLine, int endLine)
+    StatementNode* createConstStatement(int lineNumber, ConstDeclNode* decls, int startLine, int endLine)
     {
-        ConstStatementNode* result = new (m_globalData) ConstStatementNode(m_globalData, decls);
+        ConstStatementNode* result = new (m_globalData) ConstStatementNode(lineNumber, decls);
         result->setLoc(startLine, endLine);
         return result;
     }
 
-    ConstDeclNode* appendConstDecl(ConstDeclNode* tail, const Identifier* name, ExpressionNode* initializer)
+    ConstDeclNode* appendConstDecl(int lineNumber, ConstDeclNode* tail, const Identifier* name, ExpressionNode* initializer)
     {
-        ConstDeclNode* result = new (m_globalData) ConstDeclNode(m_globalData, *name, initializer);
+        ConstDeclNode* result = new (m_globalData) ConstDeclNode(lineNumber, *name, initializer);
         if (tail)
             tail->m_next = result;
         return result;
@@ -499,7 +499,7 @@ public:
         m_scope.m_varDeclarations->data.append(std::make_pair(ident, attrs));
     }
 
-    ExpressionNode* combineCommaNodes(ExpressionNode* list, ExpressionNode* init)
+    ExpressionNode* combineCommaNodes(int lineNumber, ExpressionNode* list, ExpressionNode* init)
     {
         if (!list)
             return init;
@@ -507,7 +507,7 @@ public:
             static_cast<CommaNode*>(list)->append(init);
             return list;
         }
-        return new (m_globalData) CommaNode(m_globalData, list, init);
+        return new (m_globalData) CommaNode(lineNumber, list, init);
     }
 
     int evalCount() const { return m_evalCount; }
@@ -535,10 +535,10 @@ public:
         ASSERT(operandStackDepth >= 0);
         m_binaryOperandStack.resize(m_binaryOperandStack.size() - amount);
     }
-    void appendBinaryOperation(int& operandStackDepth, int&, const BinaryOperand& lhs, const BinaryOperand& rhs)
+    void appendBinaryOperation(int lineNumber, int& operandStackDepth, int&, const BinaryOperand& lhs, const BinaryOperand& rhs)
     {
         operandStackDepth++;
-        m_binaryOperandStack.append(std::make_pair(makeBinaryNode(m_binaryOperatorStack.last().first, lhs, rhs), BinaryOpInfo(lhs.second, rhs.second)));
+        m_binaryOperandStack.append(std::make_pair(makeBinaryNode(lineNumber, m_binaryOperatorStack.last().first, lhs, rhs), BinaryOpInfo(lhs.second, rhs.second)));
     }
     void operatorStackAppend(int& operatorStackDepth, int op, int precedence)
     {
@@ -580,9 +580,9 @@ public:
         m_assignmentInfoStack.append(AssignmentInfo(node, start, divot, assignmentCount, op));
     }
 
-    ExpressionNode* createAssignment(int& assignmentStackDepth, ExpressionNode* rhs, int initialAssignmentCount, int currentAssignmentCount, int lastTokenEnd)
+    ExpressionNode* createAssignment(int lineNumber, int& assignmentStackDepth, ExpressionNode* rhs, int initialAssignmentCount, int currentAssignmentCount, int lastTokenEnd)
     {
-        ExpressionNode* result = makeAssignNode(m_assignmentInfoStack.last().m_node, m_assignmentInfoStack.last().m_op, rhs, m_assignmentInfoStack.last().m_initAssignments != initialAssignmentCount, m_assignmentInfoStack.last().m_initAssignments != currentAssignmentCount, m_assignmentInfoStack.last().m_start, m_assignmentInfoStack.last().m_divot + 1, lastTokenEnd);
+        ExpressionNode* result = makeAssignNode(lineNumber, m_assignmentInfoStack.last().m_node, m_assignmentInfoStack.last().m_op, rhs, m_assignmentInfoStack.last().m_initAssignments != initialAssignmentCount, m_assignmentInfoStack.last().m_initAssignments != currentAssignmentCount, m_assignmentInfoStack.last().m_start, m_assignmentInfoStack.last().m_divot + 1, lastTokenEnd);
         m_assignmentInfoStack.removeLast();
         assignmentStackDepth--;
         return result;
@@ -625,13 +625,13 @@ private:
         m_evalCount++;
         m_scope.m_features |= EvalFeature;
     }
-    ExpressionNode* createNumber(double d)
+    ExpressionNode* createNumber(int lineNumber, double d)
     {
-        return new (m_globalData) NumberNode(m_globalData, d);
+        return new (m_globalData) NumberNode(lineNumber, d);
     }
     
     JSGlobalData* m_globalData;
-    Lexer* m_lexer;
+    SourceCode* m_sourceCode;
     Scope m_scope;
     Vector<BinaryOperand, 10> m_binaryOperandStack;
     Vector<AssignmentInfo, 10> m_assignmentInfoStack;
@@ -640,33 +640,33 @@ private:
     int m_evalCount;
 };
 
-ExpressionNode* ASTBuilder::makeTypeOfNode(ExpressionNode* expr)
+ExpressionNode* ASTBuilder::makeTypeOfNode(int lineNumber, ExpressionNode* expr)
 {
     if (expr->isResolveNode()) {
         ResolveNode* resolve = static_cast<ResolveNode*>(expr);
-        return new (m_globalData) TypeOfResolveNode(m_globalData, resolve->identifier());
+        return new (m_globalData) TypeOfResolveNode(lineNumber, resolve->identifier());
     }
-    return new (m_globalData) TypeOfValueNode(m_globalData, expr);
+    return new (m_globalData) TypeOfValueNode(lineNumber, expr);
 }
 
-ExpressionNode* ASTBuilder::makeDeleteNode(ExpressionNode* expr, int start, int divot, int end)
+ExpressionNode* ASTBuilder::makeDeleteNode(int lineNumber, ExpressionNode* expr, int start, int divot, int end)
 {
     if (!expr->isLocation())
-        return new (m_globalData) DeleteValueNode(m_globalData, expr);
+        return new (m_globalData) DeleteValueNode(lineNumber, expr);
     if (expr->isResolveNode()) {
         ResolveNode* resolve = static_cast<ResolveNode*>(expr);
-        return new (m_globalData) DeleteResolveNode(m_globalData, resolve->identifier(), divot, divot - start, end - divot);
+        return new (m_globalData) DeleteResolveNode(lineNumber, resolve->identifier(), divot, divot - start, end - divot);
     }
     if (expr->isBracketAccessorNode()) {
         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
-        return new (m_globalData) DeleteBracketNode(m_globalData, bracket->base(), bracket->subscript(), divot, divot - start, end - divot);
+        return new (m_globalData) DeleteBracketNode(lineNumber, bracket->base(), bracket->subscript(), divot, divot - start, end - divot);
     }
     ASSERT(expr->isDotAccessorNode());
     DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
-    return new (m_globalData) DeleteDotNode(m_globalData, dot->base(), dot->identifier(), divot, divot - start, end - divot);
+    return new (m_globalData) DeleteDotNode(lineNumber, dot->base(), dot->identifier(), divot, divot - start, end - divot);
 }
 
-ExpressionNode* ASTBuilder::makeNegateNode(ExpressionNode* n)
+ExpressionNode* ASTBuilder::makeNegateNode(int lineNumber, ExpressionNode* n)
 {
     if (n->isNumber()) {
         NumberNode* numberNode = static_cast<NumberNode*>(n);
@@ -674,128 +674,128 @@ ExpressionNode* ASTBuilder::makeNegateNode(ExpressionNode* n)
         return numberNode;
     }
 
-    return new (m_globalData) NegateNode(m_globalData, n);
+    return new (m_globalData) NegateNode(lineNumber, n);
 }
 
-ExpressionNode* ASTBuilder::makeBitwiseNotNode(ExpressionNode* expr)
+ExpressionNode* ASTBuilder::makeBitwiseNotNode(int lineNumber, ExpressionNode* expr)
 {
     if (expr->isNumber())
-        return createNumber(~toInt32(static_cast<NumberNode*>(expr)->value()));
-    return new (m_globalData) BitwiseNotNode(m_globalData, expr);
+        return createNumber(lineNumber, ~toInt32(static_cast<NumberNode*>(expr)->value()));
+    return new (m_globalData) BitwiseNotNode(lineNumber, expr);
 }
 
-ExpressionNode* ASTBuilder::makeMultNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+ExpressionNode* ASTBuilder::makeMultNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 {
     expr1 = expr1->stripUnaryPlus();
     expr2 = expr2->stripUnaryPlus();
 
     if (expr1->isNumber() && expr2->isNumber())
-        return createNumber(static_cast<NumberNode*>(expr1)->value() * static_cast<NumberNode*>(expr2)->value());
+        return createNumber(lineNumber, static_cast<NumberNode*>(expr1)->value() * static_cast<NumberNode*>(expr2)->value());
 
     if (expr1->isNumber() && static_cast<NumberNode*>(expr1)->value() == 1)
-        return new (m_globalData) UnaryPlusNode(m_globalData, expr2);
+        return new (m_globalData) UnaryPlusNode(lineNumber, expr2);
 
     if (expr2->isNumber() && static_cast<NumberNode*>(expr2)->value() == 1)
-        return new (m_globalData) UnaryPlusNode(m_globalData, expr1);
+        return new (m_globalData) UnaryPlusNode(lineNumber, expr1);
 
-    return new (m_globalData) MultNode(m_globalData, expr1, expr2, rightHasAssignments);
+    return new (m_globalData) MultNode(lineNumber, expr1, expr2, rightHasAssignments);
 }
 
-ExpressionNode* ASTBuilder::makeDivNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+ExpressionNode* ASTBuilder::makeDivNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 {
     expr1 = expr1->stripUnaryPlus();
     expr2 = expr2->stripUnaryPlus();
 
     if (expr1->isNumber() && expr2->isNumber())
-        return createNumber(static_cast<NumberNode*>(expr1)->value() / static_cast<NumberNode*>(expr2)->value());
-    return new (m_globalData) DivNode(m_globalData, expr1, expr2, rightHasAssignments);
+        return createNumber(lineNumber, static_cast<NumberNode*>(expr1)->value() / static_cast<NumberNode*>(expr2)->value());
+    return new (m_globalData) DivNode(lineNumber, expr1, expr2, rightHasAssignments);
 }
 
-ExpressionNode* ASTBuilder::makeModNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+ExpressionNode* ASTBuilder::makeModNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 {
     expr1 = expr1->stripUnaryPlus();
     expr2 = expr2->stripUnaryPlus();
     
     if (expr1->isNumber() && expr2->isNumber())
-        return createNumber(fmod(static_cast<NumberNode*>(expr1)->value(), static_cast<NumberNode*>(expr2)->value()));
-    return new (m_globalData) ModNode(m_globalData, expr1, expr2, rightHasAssignments);
+        return createNumber(lineNumber, fmod(static_cast<NumberNode*>(expr1)->value(), static_cast<NumberNode*>(expr2)->value()));
+    return new (m_globalData) ModNode(lineNumber, expr1, expr2, rightHasAssignments);
 }
 
-ExpressionNode* ASTBuilder::makeAddNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+ExpressionNode* ASTBuilder::makeAddNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 {
     if (expr1->isNumber() && expr2->isNumber())
-        return createNumber(static_cast<NumberNode*>(expr1)->value() + static_cast<NumberNode*>(expr2)->value());
-    return new (m_globalData) AddNode(m_globalData, expr1, expr2, rightHasAssignments);
+        return createNumber(lineNumber, static_cast<NumberNode*>(expr1)->value() + static_cast<NumberNode*>(expr2)->value());
+    return new (m_globalData) AddNode(lineNumber, expr1, expr2, rightHasAssignments);
 }
 
-ExpressionNode* ASTBuilder::makeSubNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+ExpressionNode* ASTBuilder::makeSubNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 {
     expr1 = expr1->stripUnaryPlus();
     expr2 = expr2->stripUnaryPlus();
 
     if (expr1->isNumber() && expr2->isNumber())
-        return createNumber(static_cast<NumberNode*>(expr1)->value() - static_cast<NumberNode*>(expr2)->value());
-    return new (m_globalData) SubNode(m_globalData, expr1, expr2, rightHasAssignments);
+        return createNumber(lineNumber, static_cast<NumberNode*>(expr1)->value() - static_cast<NumberNode*>(expr2)->value());
+    return new (m_globalData) SubNode(lineNumber, expr1, expr2, rightHasAssignments);
 }
 
-ExpressionNode* ASTBuilder::makeLeftShiftNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+ExpressionNode* ASTBuilder::makeLeftShiftNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 {
     if (expr1->isNumber() && expr2->isNumber())
-        return createNumber(toInt32(static_cast<NumberNode*>(expr1)->value()) << (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
-    return new (m_globalData) LeftShiftNode(m_globalData, expr1, expr2, rightHasAssignments);
+        return createNumber(lineNumber, toInt32(static_cast<NumberNode*>(expr1)->value()) << (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
+    return new (m_globalData) LeftShiftNode(lineNumber, expr1, expr2, rightHasAssignments);
 }
 
-ExpressionNode* ASTBuilder::makeRightShiftNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+ExpressionNode* ASTBuilder::makeRightShiftNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 {
     if (expr1->isNumber() && expr2->isNumber())
-        return createNumber(toInt32(static_cast<NumberNode*>(expr1)->value()) >> (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
-    return new (m_globalData) RightShiftNode(m_globalData, expr1, expr2, rightHasAssignments);
+        return createNumber(lineNumber, toInt32(static_cast<NumberNode*>(expr1)->value()) >> (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
+    return new (m_globalData) RightShiftNode(lineNumber, expr1, expr2, rightHasAssignments);
 }
 
-ExpressionNode* ASTBuilder::makeURightShiftNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+ExpressionNode* ASTBuilder::makeURightShiftNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 {
     if (expr1->isNumber() && expr2->isNumber())
-        return createNumber(toUInt32(static_cast<NumberNode*>(expr1)->value()) >> (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
-    return new (m_globalData) UnsignedRightShiftNode(m_globalData, expr1, expr2, rightHasAssignments);
+        return createNumber(lineNumber, toUInt32(static_cast<NumberNode*>(expr1)->value()) >> (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
+    return new (m_globalData) UnsignedRightShiftNode(lineNumber, expr1, expr2, rightHasAssignments);
 }
 
-ExpressionNode* ASTBuilder::makeBitOrNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+ExpressionNode* ASTBuilder::makeBitOrNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 {
     if (expr1->isNumber() && expr2->isNumber())
-        return createNumber(toInt32(static_cast<NumberNode*>(expr1)->value()) | toInt32(static_cast<NumberNode*>(expr2)->value()));
-    return new (m_globalData) BitOrNode(m_globalData, expr1, expr2, rightHasAssignments);
+        return createNumber(lineNumber, toInt32(static_cast<NumberNode*>(expr1)->value()) | toInt32(static_cast<NumberNode*>(expr2)->value()));
+    return new (m_globalData) BitOrNode(lineNumber, expr1, expr2, rightHasAssignments);
 }
 
-ExpressionNode* ASTBuilder::makeBitAndNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+ExpressionNode* ASTBuilder::makeBitAndNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 {
     if (expr1->isNumber() && expr2->isNumber())
-        return createNumber(toInt32(static_cast<NumberNode*>(expr1)->value()) & toInt32(static_cast<NumberNode*>(expr2)->value()));
-    return new (m_globalData) BitAndNode(m_globalData, expr1, expr2, rightHasAssignments);
+        return createNumber(lineNumber, toInt32(static_cast<NumberNode*>(expr1)->value()) & toInt32(static_cast<NumberNode*>(expr2)->value()));
+    return new (m_globalData) BitAndNode(lineNumber, expr1, expr2, rightHasAssignments);
 }
 
-ExpressionNode* ASTBuilder::makeBitXOrNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+ExpressionNode* ASTBuilder::makeBitXOrNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 {
     if (expr1->isNumber() && expr2->isNumber())
-        return createNumber(toInt32(static_cast<NumberNode*>(expr1)->value()) ^ toInt32(static_cast<NumberNode*>(expr2)->value()));
-    return new (m_globalData) BitXOrNode(m_globalData, expr1, expr2, rightHasAssignments);
+        return createNumber(lineNumber, toInt32(static_cast<NumberNode*>(expr1)->value()) ^ toInt32(static_cast<NumberNode*>(expr2)->value()));
+    return new (m_globalData) BitXOrNode(lineNumber, expr1, expr2, rightHasAssignments);
 }
 
-ExpressionNode* ASTBuilder::makeFunctionCallNode(ExpressionNode* func, ArgumentsNode* args, int start, int divot, int end)
+ExpressionNode* ASTBuilder::makeFunctionCallNode(int lineNumber, ExpressionNode* func, ArgumentsNode* args, int start, int divot, int end)
 {
     if (!func->isLocation())
-        return new (m_globalData) FunctionCallValueNode(m_globalData, func, args, divot, divot - start, end - divot);
+        return new (m_globalData) FunctionCallValueNode(lineNumber, func, args, divot, divot - start, end - divot);
     if (func->isResolveNode()) {
         ResolveNode* resolve = static_cast<ResolveNode*>(func);
         const Identifier& identifier = resolve->identifier();
         if (identifier == m_globalData->propertyNames->eval) {
             usesEval();
-            return new (m_globalData) EvalFunctionCallNode(m_globalData, args, divot, divot - start, end - divot);
+            return new (m_globalData) EvalFunctionCallNode(lineNumber, args, divot, divot - start, end - divot);
         }
-        return new (m_globalData) FunctionCallResolveNode(m_globalData, identifier, args, divot, divot - start, end - divot);
+        return new (m_globalData) FunctionCallResolveNode(lineNumber, identifier, args, divot, divot - start, end - divot);
     }
     if (func->isBracketAccessorNode()) {
         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(func);
-        FunctionCallBracketNode* node = new (m_globalData) FunctionCallBracketNode(m_globalData, bracket->base(), bracket->subscript(), args, divot, divot - start, end - divot);
+        FunctionCallBracketNode* node = new (m_globalData) FunctionCallBracketNode(lineNumber, bracket->base(), bracket->subscript(), args, divot, divot - start, end - divot);
         node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
         return node;
     }
@@ -803,173 +803,173 @@ ExpressionNode* ASTBuilder::makeFunctionCallNode(ExpressionNode* func, Arguments
     DotAccessorNode* dot = static_cast<DotAccessorNode*>(func);
     FunctionCallDotNode* node;
     if (dot->identifier() == m_globalData->propertyNames->call)
-        node = new (m_globalData) CallFunctionCallDotNode(m_globalData, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
+        node = new (m_globalData) CallFunctionCallDotNode(lineNumber, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
     else if (dot->identifier() == m_globalData->propertyNames->apply)
-        node = new (m_globalData) ApplyFunctionCallDotNode(m_globalData, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
+        node = new (m_globalData) ApplyFunctionCallDotNode(lineNumber, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
     else
-        node = new (m_globalData) FunctionCallDotNode(m_globalData, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
+        node = new (m_globalData) FunctionCallDotNode(lineNumber, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
     node->setSubexpressionInfo(dot->divot(), dot->endOffset());
     return node;
 }
 
-ExpressionNode* ASTBuilder::makeBinaryNode(int token, pair<ExpressionNode*, BinaryOpInfo> lhs, pair<ExpressionNode*, BinaryOpInfo> rhs)
+ExpressionNode* ASTBuilder::makeBinaryNode(int lineNumber, int token, pair<ExpressionNode*, BinaryOpInfo> lhs, pair<ExpressionNode*, BinaryOpInfo> rhs)
 {
     switch (token) {
     case OR:
-        return new (m_globalData) LogicalOpNode(m_globalData, lhs.first, rhs.first, OpLogicalOr);
+        return new (m_globalData) LogicalOpNode(lineNumber, lhs.first, rhs.first, OpLogicalOr);
 
     case AND:
-        return new (m_globalData) LogicalOpNode(m_globalData, lhs.first, rhs.first, OpLogicalAnd);
+        return new (m_globalData) LogicalOpNode(lineNumber, lhs.first, rhs.first, OpLogicalAnd);
 
     case BITOR:
-        return makeBitOrNode(lhs.first, rhs.first, rhs.second.hasAssignment);
+        return makeBitOrNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case BITXOR:
-        return makeBitXOrNode(lhs.first, rhs.first, rhs.second.hasAssignment);
+        return makeBitXOrNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case BITAND:
-        return makeBitAndNode(lhs.first, rhs.first, rhs.second.hasAssignment);
+        return makeBitAndNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case EQEQ:
-        return new (m_globalData) EqualNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
+        return new (m_globalData) EqualNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case NE:
-        return new (m_globalData) NotEqualNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
+        return new (m_globalData) NotEqualNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case STREQ:
-        return new (m_globalData) StrictEqualNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
+        return new (m_globalData) StrictEqualNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case STRNEQ:
-        return new (m_globalData) NotStrictEqualNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
+        return new (m_globalData) NotStrictEqualNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case LT:
-        return new (m_globalData) LessNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
+        return new (m_globalData) LessNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case GT:
-        return new (m_globalData) GreaterNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
+        return new (m_globalData) GreaterNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case LE:
-        return new (m_globalData) LessEqNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
+        return new (m_globalData) LessEqNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case GE:
-        return new (m_globalData) GreaterEqNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
+        return new (m_globalData) GreaterEqNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case INSTANCEOF: {
-        InstanceOfNode* node = new (m_globalData) InstanceOfNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
+        InstanceOfNode* node = new (m_globalData) InstanceOfNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
         setExceptionLocation(node, lhs.second.start, rhs.second.start, rhs.second.end);
         return node;
     }
 
     case INTOKEN: {
-        InNode* node = new (m_globalData) InNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
+        InNode* node = new (m_globalData) InNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
         setExceptionLocation(node, lhs.second.start, rhs.second.start, rhs.second.end);
         return node;
     }
 
     case LSHIFT:
-        return makeLeftShiftNode(lhs.first, rhs.first, rhs.second.hasAssignment);
+        return makeLeftShiftNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case RSHIFT:
-        return makeRightShiftNode(lhs.first, rhs.first, rhs.second.hasAssignment);
+        return makeRightShiftNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case URSHIFT:
-        return makeURightShiftNode(lhs.first, rhs.first, rhs.second.hasAssignment);
+        return makeURightShiftNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case PLUS:
-        return makeAddNode(lhs.first, rhs.first, rhs.second.hasAssignment);
+        return makeAddNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case MINUS:
-        return makeSubNode(lhs.first, rhs.first, rhs.second.hasAssignment);
+        return makeSubNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case TIMES:
-        return makeMultNode(lhs.first, rhs.first, rhs.second.hasAssignment);
+        return makeMultNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case DIVIDE:
-        return makeDivNode(lhs.first, rhs.first, rhs.second.hasAssignment);
+        return makeDivNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 
     case MOD:
-        return makeModNode(lhs.first, rhs.first, rhs.second.hasAssignment);
+        return makeModNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
     }
     CRASH();
     return 0;
 }
 
-ExpressionNode* ASTBuilder::makeAssignNode(ExpressionNode* loc, Operator op, ExpressionNode* expr, bool locHasAssignments, bool exprHasAssignments, int start, int divot, int end)
+ExpressionNode* ASTBuilder::makeAssignNode(int lineNumber, ExpressionNode* loc, Operator op, ExpressionNode* expr, bool locHasAssignments, bool exprHasAssignments, int start, int divot, int end)
 {
     usesAssignment();
     if (!loc->isLocation())
-        return new (m_globalData) AssignErrorNode(m_globalData, loc, op, expr, divot, divot - start, end - divot);
+        return new (m_globalData) AssignErrorNode(lineNumber, loc, op, expr, divot, divot - start, end - divot);
 
     if (loc->isResolveNode()) {
         ResolveNode* resolve = static_cast<ResolveNode*>(loc);
         if (op == OpEqual) {
-            AssignResolveNode* node = new (m_globalData) AssignResolveNode(m_globalData, resolve->identifier(), expr, exprHasAssignments);
+            AssignResolveNode* node = new (m_globalData) AssignResolveNode(lineNumber, resolve->identifier(), expr, exprHasAssignments);
             setExceptionLocation(node, start, divot, end);
             return node;
         }
-        return new (m_globalData) ReadModifyResolveNode(m_globalData, resolve->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
+        return new (m_globalData) ReadModifyResolveNode(lineNumber, resolve->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
     }
     if (loc->isBracketAccessorNode()) {
         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(loc);
         if (op == OpEqual)
-            return new (m_globalData) AssignBracketNode(m_globalData, bracket->base(), bracket->subscript(), expr, locHasAssignments, exprHasAssignments, bracket->divot(), bracket->divot() - start, end - bracket->divot());
-        ReadModifyBracketNode* node = new (m_globalData) ReadModifyBracketNode(m_globalData, bracket->base(), bracket->subscript(), op, expr, locHasAssignments, exprHasAssignments, divot, divot - start, end - divot);
+            return new (m_globalData) AssignBracketNode(lineNumber, bracket->base(), bracket->subscript(), expr, locHasAssignments, exprHasAssignments, bracket->divot(), bracket->divot() - start, end - bracket->divot());
+        ReadModifyBracketNode* node = new (m_globalData) ReadModifyBracketNode(lineNumber, bracket->base(), bracket->subscript(), op, expr, locHasAssignments, exprHasAssignments, divot, divot - start, end - divot);
         node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
         return node;
     }
     ASSERT(loc->isDotAccessorNode());
     DotAccessorNode* dot = static_cast<DotAccessorNode*>(loc);
     if (op == OpEqual)
-        return new (m_globalData) AssignDotNode(m_globalData, dot->base(), dot->identifier(), expr, exprHasAssignments, dot->divot(), dot->divot() - start, end - dot->divot());
+        return new (m_globalData) AssignDotNode(lineNumber, dot->base(), dot->identifier(), expr, exprHasAssignments, dot->divot(), dot->divot() - start, end - dot->divot());
 
-    ReadModifyDotNode* node = new (m_globalData) ReadModifyDotNode(m_globalData, dot->base(), dot->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
+    ReadModifyDotNode* node = new (m_globalData) ReadModifyDotNode(lineNumber, dot->base(), dot->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
     node->setSubexpressionInfo(dot->divot(), dot->endOffset());
     return node;
 }
 
-ExpressionNode* ASTBuilder::makePrefixNode(ExpressionNode* expr, Operator op, int start, int divot, int end)
+ExpressionNode* ASTBuilder::makePrefixNode(int lineNumber, ExpressionNode* expr, Operator op, int start, int divot, int end)
 {
     usesAssignment();
     if (!expr->isLocation())
-        return new (m_globalData) PrefixErrorNode(m_globalData, expr, op, divot, divot - start, end - divot);
+        return new (m_globalData) PrefixErrorNode(lineNumber, expr, op, divot, divot - start, end - divot);
 
     if (expr->isResolveNode()) {
         ResolveNode* resolve = static_cast<ResolveNode*>(expr);
-        return new (m_globalData) PrefixResolveNode(m_globalData, resolve->identifier(), op, divot, divot - start, end - divot);
+        return new (m_globalData) PrefixResolveNode(lineNumber, resolve->identifier(), op, divot, divot - start, end - divot);
     }
     if (expr->isBracketAccessorNode()) {
         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
-        PrefixBracketNode* node = new (m_globalData) PrefixBracketNode(m_globalData, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
+        PrefixBracketNode* node = new (m_globalData) PrefixBracketNode(lineNumber, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
         node->setSubexpressionInfo(bracket->divot(), bracket->startOffset());
         return node;
     }
     ASSERT(expr->isDotAccessorNode());
     DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
-    PrefixDotNode* node = new (m_globalData) PrefixDotNode(m_globalData, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
+    PrefixDotNode* node = new (m_globalData) PrefixDotNode(lineNumber, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
     node->setSubexpressionInfo(dot->divot(), dot->startOffset());
     return node;
 }
 
-ExpressionNode* ASTBuilder::makePostfixNode(ExpressionNode* expr, Operator op, int start, int divot, int end)
+ExpressionNode* ASTBuilder::makePostfixNode(int lineNumber, ExpressionNode* expr, Operator op, int start, int divot, int end)
 {
     usesAssignment();
     if (!expr->isLocation())
-        return new (m_globalData) PostfixErrorNode(m_globalData, expr, op, divot, divot - start, end - divot);
+        return new (m_globalData) PostfixErrorNode(lineNumber, expr, op, divot, divot - start, end - divot);
 
     if (expr->isResolveNode()) {
         ResolveNode* resolve = static_cast<ResolveNode*>(expr);
-        return new (m_globalData) PostfixResolveNode(m_globalData, resolve->identifier(), op, divot, divot - start, end - divot);
+        return new (m_globalData) PostfixResolveNode(lineNumber, resolve->identifier(), op, divot, divot - start, end - divot);
     }
     if (expr->isBracketAccessorNode()) {
         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
-        PostfixBracketNode* node = new (m_globalData) PostfixBracketNode(m_globalData, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
+        PostfixBracketNode* node = new (m_globalData) PostfixBracketNode(lineNumber, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
         node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
         return node;
 
     }
     ASSERT(expr->isDotAccessorNode());
     DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
-    PostfixDotNode* node = new (m_globalData) PostfixDotNode(m_globalData, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
+    PostfixDotNode* node = new (m_globalData) PostfixDotNode(lineNumber, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
     node->setSubexpressionInfo(dot->divot(), dot->endOffset());
     return node;
 }
diff --git a/Source/JavaScriptCore/parser/JSParser.cpp b/Source/JavaScriptCore/parser/JSParser.cpp
deleted file mode 100644 (file)
index a8eb4a9..0000000
+++ /dev/null
@@ -1,2478 +0,0 @@
-/*
- * Copyright (C) 2010 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
- * THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "config.h"
-
-#include "JSParser.h"
-
-using namespace JSC;
-
-#include "CodeBlock.h"
-#include "JSGlobalData.h"
-#include "NodeInfo.h"
-#include "ASTBuilder.h"
-#include "SourceProvider.h"
-#include "SourceProviderCacheItem.h"
-#include <wtf/HashFunctions.h>
-#include <wtf/OwnPtr.h>
-#include <wtf/WTFThreadData.h>
-#include <utility>
-
-using namespace std;
-
-namespace JSC {
-#define fail() do { if (!m_error) updateErrorMessage(); return 0; } while (0)
-#define failWithToken(tok) do { if (!m_error) updateErrorMessage(tok); return 0; } while (0)
-#define failWithMessage(msg) do { if (!m_error) updateErrorMessage(msg); return 0; } while (0)
-#define failWithNameAndMessage(before, name, after) do { if (!m_error) updateErrorWithNameAndMessage(before, name, after); 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 { failIfFalseWithMessage(canRecurse(), "Code nested too deeply."); } while (0)
-
-// Macros to make the more common TreeBuilder types a little less verbose
-#define TreeStatement typename TreeBuilder::Statement
-#define TreeExpression typename TreeBuilder::Expression
-#define TreeFormalParameterList typename TreeBuilder::FormalParameterList
-#define TreeSourceElements typename TreeBuilder::SourceElements
-#define TreeClause typename TreeBuilder::Clause
-#define TreeClauseList typename TreeBuilder::ClauseList
-#define TreeConstDeclList typename TreeBuilder::ConstDeclList
-#define TreeArguments typename TreeBuilder::Arguments
-#define TreeArgumentsList typename TreeBuilder::ArgumentsList
-#define TreeFunctionBody typename TreeBuilder::FunctionBody
-#define TreeProperty typename TreeBuilder::Property
-#define TreePropertyList typename TreeBuilder::PropertyList
-
-COMPILE_ASSERT(LastUntaggedToken < 64, LessThan64UntaggedTokens);
-
-class JSParser {
-public:
-    JSParser(Lexer*, JSGlobalData*, FunctionParameters*, bool isStrictContext, bool isFunction, const SourceCode*);
-    UString parseProgram();
-private:
-    struct AllowInOverride {
-        AllowInOverride(JSParser* parser)
-            : m_parser(parser)
-            , m_oldAllowsIn(parser->m_allowsIn)
-        {
-            parser->m_allowsIn = true;
-        }
-        ~AllowInOverride()
-        {
-            m_parser->m_allowsIn = m_oldAllowsIn;
-        }
-        JSParser* m_parser;
-        bool m_oldAllowsIn;
-    };
-    
-    struct ScopeLabelInfo {
-        ScopeLabelInfo(StringImpl* ident, bool isLoop)
-        : m_ident(ident)
-        , m_isLoop(isLoop)
-        {
-        }
-        StringImpl* m_ident;
-        bool m_isLoop;
-    };
-    
-    ALWAYS_INLINE void next(unsigned lexType = 0)
-    {
-        m_lastLine = m_token.m_info.line;
-        m_lastTokenEnd = m_token.m_info.endOffset;
-        m_lexer->setLastLineNumber(m_lastLine);
-        m_token.m_type = m_lexer->lex(&m_token.m_data, &m_token.m_info, lexType, strictMode());
-    }
-    
-    ALWAYS_INLINE void nextExpectIdentifier(unsigned lexType = 0)
-    {
-        m_lastLine = m_token.m_info.line;
-        m_lastTokenEnd = m_token.m_info.endOffset;
-        m_lexer->setLastLineNumber(m_lastLine);
-        m_token.m_type = m_lexer->lexExpectIdentifier(&m_token.m_data, &m_token.m_info, lexType, strictMode());
-    }
-    
-    ALWAYS_INLINE bool nextTokenIsColon()
-    {
-        return m_lexer->nextTokenIsColon();
-    }
-
-    ALWAYS_INLINE bool consume(JSTokenType expected, unsigned flags = 0)
-    {
-        bool result = m_token.m_type == expected;
-        if (result)
-            next(flags);
-        return result;
-    }
-
-    ALWAYS_INLINE UString getToken() {
-        SourceProvider* sourceProvider = m_source->provider();
-        return UString(sourceProvider->getRange(tokenStart(), tokenEnd()).impl());
-    }
-    
-    ALWAYS_INLINE bool match(JSTokenType expected)
-    {
-        return m_token.m_type == expected;
-    }
-
-    ALWAYS_INLINE int tokenStart()
-    {
-        return m_token.m_info.startOffset;
-    }
-
-    ALWAYS_INLINE int tokenLine()
-    {
-        return m_token.m_info.line;
-    }
-
-    ALWAYS_INLINE int tokenEnd()
-    {
-        return m_token.m_info.endOffset;
-    }
-    
-    const char* getTokenName(JSTokenType tok) 
-    {
-        switch (tok) {
-        case NULLTOKEN: 
-            return "null";
-        case TRUETOKEN:
-            return "true";
-        case FALSETOKEN: 
-            return "false";
-        case BREAK: 
-            return "break";
-        case CASE: 
-            return "case";
-        case DEFAULT: 
-            return "defualt";
-        case FOR: 
-            return "for";
-        case NEW: 
-            return "new";
-        case VAR: 
-            return "var";
-        case CONSTTOKEN: 
-            return "const";
-        case CONTINUE: 
-            return "continue";
-        case FUNCTION: 
-            return "function";
-        case IF: 
-            return "if";
-        case THISTOKEN: 
-            return "this";
-        case DO: 
-            return "do";
-        case WHILE: 
-            return "while";
-        case SWITCH: 
-            return "switch";
-        case WITH: 
-            return "with";
-        case THROW: 
-            return "throw";
-        case TRY: 
-            return "try";
-        case CATCH: 
-            return "catch";
-        case FINALLY: 
-            return "finally";
-        case DEBUGGER: 
-            return "debugger";
-        case ELSE: 
-            return "else";
-        case OPENBRACE: 
-            return "{";
-        case CLOSEBRACE: 
-            return "}";
-        case OPENPAREN: 
-            return "(";
-        case CLOSEPAREN: 
-            return ")";
-        case OPENBRACKET: 
-            return "[";
-        case CLOSEBRACKET: 
-            return "]";
-        case COMMA: 
-            return ",";
-        case QUESTION: 
-            return "?";
-        case SEMICOLON: 
-            return ";";
-        case COLON: 
-            return ":";
-        case DOT: 
-            return ".";
-        case EQUAL: 
-            return "=";
-        case PLUSEQUAL: 
-            return "+=";
-        case MINUSEQUAL: 
-            return "-=";
-        case MULTEQUAL: 
-            return "*=";
-        case DIVEQUAL: 
-            return "/=";
-        case LSHIFTEQUAL: 
-            return "<<=";
-        case RSHIFTEQUAL: 
-            return ">>=";
-        case URSHIFTEQUAL: 
-            return ">>>=";
-        case ANDEQUAL: 
-            return "&=";
-        case MODEQUAL: 
-            return "%=";
-        case XOREQUAL: 
-            return "^=";
-        case OREQUAL: 
-            return "|=";
-        case AUTOPLUSPLUS: 
-        case PLUSPLUS: 
-            return "++";
-        case AUTOMINUSMINUS: 
-        case MINUSMINUS: 
-            return "--";
-        case EXCLAMATION: 
-            return "!";
-        case TILDE: 
-            return "~";
-        case TYPEOF: 
-            return "typeof";
-        case VOIDTOKEN: 
-            return "void";
-        case DELETETOKEN: 
-            return "delete";
-        case OR: 
-            return "||";
-        case AND: 
-            return "&&";
-        case BITOR: 
-            return "|";
-        case BITXOR: 
-            return "^";
-        case BITAND: 
-            return "&";
-        case EQEQ: 
-            return "==";
-        case NE: 
-            return "!=";
-        case STREQ: 
-            return "===";
-        case STRNEQ: 
-            return "!==";
-        case LT: 
-            return "<";
-        case GT: 
-            return ">";
-        case LE: 
-            return "<=";
-        case GE: 
-            return ">=";
-        case INSTANCEOF: 
-            return "instanceof";
-        case INTOKEN: 
-            return "in";
-        case LSHIFT: 
-            return "<<";
-        case RSHIFT: 
-            return ">>";
-        case URSHIFT: 
-            return ">>>";
-        case PLUS: 
-            return "+";
-        case MINUS: 
-            return "-";
-        case TIMES: 
-            return "*";
-        case DIVIDE: 
-            return "/";
-        case MOD: 
-            return "%";
-        case RETURN: 
-        case RESERVED_IF_STRICT:
-        case RESERVED: 
-        case NUMBER:
-        case IDENT: 
-        case STRING: 
-        case ERRORTOK:
-        case EOFTOK: 
-            return 0;
-        case LastUntaggedToken: 
-            break;
-        }
-        ASSERT_NOT_REACHED();
-        return "internal error";
-    }
-    
-    ALWAYS_INLINE void updateErrorMessageSpecialCase(JSTokenType expectedToken) 
-    {
-        String errorMessage;
-        switch (expectedToken) {
-        case RESERVED_IF_STRICT:
-            errorMessage = "Use of reserved word '";
-            errorMessage += getToken().impl();
-            errorMessage += "' in strict mode";
-            m_errorMessage = errorMessage.impl();
-            return;
-        case RESERVED:
-            errorMessage = "Use of reserved word '";
-            errorMessage += getToken().impl();
-            errorMessage += "'";
-            m_errorMessage = errorMessage.impl();
-            return;
-        case NUMBER: 
-            errorMessage = "Unexpected number '";
-            errorMessage += getToken().impl();
-            errorMessage += "'";
-            m_errorMessage = errorMessage.impl();
-            return;
-        case IDENT: 
-            errorMessage = "Expected an identifier but found '";
-            errorMessage += getToken().impl();
-            errorMessage += "' instead";
-            m_errorMessage = errorMessage.impl();
-            return;
-        case STRING: 
-            errorMessage = "Unexpected string ";
-            errorMessage += getToken().impl();
-            m_errorMessage = errorMessage.impl();
-            return;
-        case ERRORTOK: 
-            errorMessage = "Unrecognized token '";
-            errorMessage += getToken().impl();
-            errorMessage += "'";
-            m_errorMessage = errorMessage.impl();
-            return;
-        case EOFTOK:  
-            m_errorMessage = "Unexpected EOF";
-            return;
-        case RETURN:
-            m_errorMessage = "Return statements are only valid inside functions";
-            return;
-        default:
-            ASSERT_NOT_REACHED();
-            m_errorMessage = "internal error";
-            return;
-        }
-    }
-        
-    NEVER_INLINE void updateErrorMessage() 
-    {
-        m_error = true;
-        const char* name = getTokenName(m_token.m_type);
-        if (!name) 
-            updateErrorMessageSpecialCase(m_token.m_type);
-        else 
-            m_errorMessage = UString(String::format("Unexpected token '%s'", name).impl());
-    }
-    
-    NEVER_INLINE void updateErrorMessage(JSTokenType expectedToken) 
-    {
-        m_error = true;
-        const char* name = getTokenName(expectedToken);
-        if (name)
-            m_errorMessage = UString(String::format("Expected token '%s'", name).impl());
-        else {
-            if (!getTokenName(m_token.m_type))
-                updateErrorMessageSpecialCase(m_token.m_type);
-            else
-                updateErrorMessageSpecialCase(expectedToken);
-        } 
-    }
-    
-    NEVER_INLINE void updateErrorWithNameAndMessage(const char* beforeMsg, UString name, const char* afterMsg) 
-    {
-        m_error = true;
-        String prefix(beforeMsg);
-        String postfix(afterMsg);
-        prefix += " '";
-        prefix += name.impl();
-        prefix += "' ";
-        prefix += postfix;
-        m_errorMessage = prefix.impl();
-    }
-    
-    NEVER_INLINE void updateErrorMessage(const char* msg) 
-    {   
-        m_error = true;
-        m_errorMessage = UString(msg);
-    }
-    
-    void startLoop() { currentScope()->startLoop(); }
-    void endLoop() { currentScope()->endLoop(); }
-    void startSwitch() { currentScope()->startSwitch(); }
-    void endSwitch() { currentScope()->endSwitch(); }
-    void setStrictMode() { currentScope()->setStrictMode(); }
-    bool strictMode() { return currentScope()->strictMode(); }
-    bool isValidStrictMode() { return currentScope()->isValidStrictMode(); }
-    bool declareParameter(const Identifier* ident) { return currentScope()->declareParameter(ident); }
-    bool breakIsValid()
-    {
-        ScopeRef current = currentScope();
-        while (!current->breakIsValid()) {
-            if (!current.hasContainingScope())
-                return false;
-            current = current.containingScope();
-        }
-        return true;
-    }
-    bool continueIsValid()
-    {
-        ScopeRef current = currentScope();
-        while (!current->continueIsValid()) {
-            if (!current.hasContainingScope())
-                return false;
-            current = current.containingScope();
-        }
-        return true;
-    }
-    void pushLabel(const Identifier* label, bool isLoop) { currentScope()->pushLabel(label, isLoop); }
-    void popLabel() { currentScope()->popLabel(); }
-    ScopeLabelInfo* getLabel(const Identifier* label)
-    {
-        ScopeRef current = currentScope();
-        ScopeLabelInfo* result = 0;
-        while (!(result = current->getLabel(label))) {
-            if (!current.hasContainingScope())
-                return 0;
-            current = current.containingScope();
-        }
-        return result;
-    }
-
-    enum SourceElementsMode { CheckForStrictMode, DontCheckForStrictMode };
-    template <SourceElementsMode mode, class TreeBuilder> TreeSourceElements parseSourceElements(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseStatement(TreeBuilder&, const Identifier*& directive);
-    template <class TreeBuilder> TreeStatement parseFunctionDeclaration(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseVarDeclaration(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseConstDeclaration(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseDoWhileStatement(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseWhileStatement(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseForStatement(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseBreakStatement(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseContinueStatement(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseReturnStatement(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseThrowStatement(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseWithStatement(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseSwitchStatement(TreeBuilder&);
-    template <class TreeBuilder> TreeClauseList parseSwitchClauses(TreeBuilder&);
-    template <class TreeBuilder> TreeClause parseSwitchDefaultClause(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseTryStatement(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseDebuggerStatement(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseExpressionStatement(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseExpressionOrLabelStatement(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseIfStatement(TreeBuilder&);
-    template <class TreeBuilder> ALWAYS_INLINE TreeStatement parseBlockStatement(TreeBuilder&);
-    template <class TreeBuilder> TreeExpression parseExpression(TreeBuilder&);
-    template <class TreeBuilder> TreeExpression parseAssignmentExpression(TreeBuilder&);
-    template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseConditionalExpression(TreeBuilder&);
-    template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseBinaryExpression(TreeBuilder&);
-    template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseUnaryExpression(TreeBuilder&);
-    template <class TreeBuilder> TreeExpression parseMemberExpression(TreeBuilder&);
-    template <class TreeBuilder> ALWAYS_INLINE TreeExpression parsePrimaryExpression(TreeBuilder&);
-    template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseArrayLiteral(TreeBuilder&);
-    template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseObjectLiteral(TreeBuilder&);
-    template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseStrictObjectLiteral(TreeBuilder&);
-    template <class TreeBuilder> ALWAYS_INLINE TreeArguments parseArguments(TreeBuilder&);
-    template <bool strict, class TreeBuilder> ALWAYS_INLINE TreeProperty parseProperty(TreeBuilder&);
-    template <class TreeBuilder> ALWAYS_INLINE TreeFunctionBody parseFunctionBody(TreeBuilder&);
-    template <class TreeBuilder> ALWAYS_INLINE TreeFormalParameterList parseFormalParameters(TreeBuilder&);
-    template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseVarDeclarationList(TreeBuilder&, int& declarations, const Identifier*& lastIdent, TreeExpression& lastInitializer, int& identStart, int& initStart, int& initEnd);
-    template <class TreeBuilder> ALWAYS_INLINE TreeConstDeclList parseConstDeclarationList(TreeBuilder& context);
-    enum FunctionRequirements { FunctionNoRequirements, FunctionNeedsName };
-    template <FunctionRequirements, bool nameIsInContainingScope, class TreeBuilder> bool parseFunctionInfo(TreeBuilder&, const Identifier*&, TreeFormalParameterList&, TreeFunctionBody&, int& openBrace, int& closeBrace, int& bodyStartLine);
-    ALWAYS_INLINE int isBinaryOperator(JSTokenType token);
-    bool allowAutomaticSemicolon();
-
-    bool autoSemiColon()
-    {
-        if (m_token.m_type == SEMICOLON) {
-            next();
-            return true;
-        }
-        return allowAutomaticSemicolon();
-    }
-
-    bool canRecurse()
-    {
-        return m_stack.recursionCheck();
-    }
-    
-    int lastTokenEnd() const
-    {
-        return m_lastTokenEnd;
-    }
-
-    ParserArena m_arena;
-    Lexer* m_lexer;
-    StackBounds m_stack;
-    bool m_error;
-    UString m_errorMessage;
-    JSGlobalData* m_globalData;
-    JSToken m_token;
-    bool m_allowsIn;
-    int m_lastLine;
-    int m_lastTokenEnd;
-    int m_assignmentCount;
-    int m_nonLHSCount;
-    bool m_syntaxAlreadyValidated;
-    int m_statementDepth;
-    int m_nonTrivialExpressionCount;
-    const Identifier* m_lastIdentifier;
-
-    struct DepthManager {
-        DepthManager(int* depth)
-            : m_originalDepth(*depth)
-            , m_depth(depth)
-        {
-        }
-        
-        ~DepthManager()
-        {
-            *m_depth = m_originalDepth;
-        }
-        
-    private:
-        int m_originalDepth;
-        int* m_depth;
-    };
-    
-    struct Scope {
-        Scope(JSGlobalData* globalData, bool isFunction, bool strictMode)
-            : m_globalData(globalData)
-            , m_shadowsArguments(false)
-            , m_usesEval(false)
-            , m_needsFullActivation(false)
-            , m_allowsNewDecls(true)
-            , m_strictMode(strictMode)
-            , m_isFunction(isFunction)
-            , m_isFunctionBoundary(false)
-            , m_isValidStrictMode(true)
-            , m_loopDepth(0)
-            , m_switchDepth(0)
-        {
-        }
-
-        Scope(const Scope& rhs)
-            : m_globalData(rhs.m_globalData)
-            , m_shadowsArguments(rhs.m_shadowsArguments)
-            , m_usesEval(rhs.m_usesEval)
-            , m_needsFullActivation(rhs.m_needsFullActivation)
-            , m_allowsNewDecls(rhs.m_allowsNewDecls)
-            , m_strictMode(rhs.m_strictMode)
-            , m_isFunction(rhs.m_isFunction)
-            , m_isFunctionBoundary(rhs.m_isFunctionBoundary)
-            , m_isValidStrictMode(rhs.m_isValidStrictMode)
-            , m_loopDepth(rhs.m_loopDepth)
-            , m_switchDepth(rhs.m_switchDepth)
-        {
-            if (rhs.m_labels) {
-                m_labels = adoptPtr(new LabelStack);
-                
-                typedef LabelStack::const_iterator iterator;
-                iterator end = rhs.m_labels->end();
-                for (iterator it = rhs.m_labels->begin(); it != end; ++it)
-                    m_labels->append(ScopeLabelInfo(it->m_ident, it->m_isLoop));
-            }
-        }
-
-        void startSwitch() { m_switchDepth++; }
-        void endSwitch() { m_switchDepth--; }
-        void startLoop() { m_loopDepth++; }
-        void endLoop() { ASSERT(m_loopDepth); m_loopDepth--; }
-        bool inLoop() { return !!m_loopDepth; }
-        bool breakIsValid() { return m_loopDepth || m_switchDepth; }
-        bool continueIsValid() { return m_loopDepth; }
-
-        void pushLabel(const Identifier* label, bool isLoop)
-        {
-            if (!m_labels)
-                m_labels = adoptPtr(new LabelStack);
-            m_labels->append(ScopeLabelInfo(label->impl(), isLoop));
-        }
-
-        void popLabel()
-        {
-            ASSERT(m_labels);
-            ASSERT(m_labels->size());
-            m_labels->removeLast();
-        }
-
-        ScopeLabelInfo* getLabel(const Identifier* label)
-        {
-            if (!m_labels)
-                return 0;
-            for (int i = m_labels->size(); i > 0; i--) {
-                if (m_labels->at(i - 1).m_ident == label->impl())
-                    return &m_labels->at(i - 1);
-            }
-            return 0;
-        }
-
-        void setIsFunction()
-        {
-            m_isFunction = true;
-            m_isFunctionBoundary = true;
-        }
-        bool isFunction() { return m_isFunction; }
-        bool isFunctionBoundary() { return m_isFunctionBoundary; }
-        
-        bool declareVariable(const Identifier* ident)
-        {
-            bool isValidStrictMode = m_globalData->propertyNames->eval != *ident && m_globalData->propertyNames->arguments != *ident;
-            m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
-            m_declaredVariables.add(ident->ustring().impl());
-            return isValidStrictMode;
-        }
-        
-        void declareWrite(const Identifier* ident)
-        {
-            ASSERT(m_strictMode);
-            m_writtenVariables.add(ident->impl());
-        }
-
-        void preventNewDecls() { m_allowsNewDecls = false; }
-        bool allowsNewDecls() const { return m_allowsNewDecls; }
-
-        bool declareParameter(const Identifier* ident)
-        {
-            bool isArguments = m_globalData->propertyNames->arguments == *ident;
-            bool isValidStrictMode = m_declaredVariables.add(ident->ustring().impl()).second && m_globalData->propertyNames->eval != *ident && !isArguments;
-            m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
-            if (isArguments)
-                m_shadowsArguments = true;
-            return isValidStrictMode;
-        }
-        
-        void useVariable(const Identifier* ident, bool isEval)
-        {
-            m_usesEval |= isEval;
-            m_usedVariables.add(ident->ustring().impl());
-        }
-        
-        void setNeedsFullActivation() { m_needsFullActivation = true; }
-        
-        bool collectFreeVariables(Scope* nestedScope, bool shouldTrackClosedVariables)
-        {
-            if (nestedScope->m_usesEval)
-                m_usesEval = true;
-            IdentifierSet::iterator end = nestedScope->m_usedVariables.end();
-            for (IdentifierSet::iterator ptr = nestedScope->m_usedVariables.begin(); ptr != end; ++ptr) {
-                if (nestedScope->m_declaredVariables.contains(*ptr))
-                    continue;
-                m_usedVariables.add(*ptr);
-                if (shouldTrackClosedVariables)
-                    m_closedVariables.add(*ptr);
-            }
-            if (nestedScope->m_writtenVariables.size()) {
-                IdentifierSet::iterator end = nestedScope->m_writtenVariables.end();
-                for (IdentifierSet::iterator ptr = nestedScope->m_writtenVariables.begin(); ptr != end; ++ptr) {
-                    if (nestedScope->m_declaredVariables.contains(*ptr))
-                        continue;
-                    m_writtenVariables.add(*ptr);
-                }
-            }
-
-            return true;
-        }
-
-        void getUncapturedWrittenVariables(IdentifierSet& writtenVariables)
-        {
-            IdentifierSet::iterator end = m_writtenVariables.end();
-            for (IdentifierSet::iterator ptr = m_writtenVariables.begin(); ptr != end; ++ptr) {
-                if (!m_declaredVariables.contains(*ptr))
-                    writtenVariables.add(*ptr);
-            }
-        }
-
-        void getCapturedVariables(IdentifierSet& capturedVariables)
-        {
-            if (m_needsFullActivation || m_usesEval) {
-                capturedVariables.swap(m_declaredVariables);
-                return;
-            }
-            for (IdentifierSet::iterator ptr = m_closedVariables.begin(); ptr != m_closedVariables.end(); ++ptr) {
-                if (!m_declaredVariables.contains(*ptr))
-                    continue;
-                capturedVariables.add(*ptr);
-            }
-        }
-        void setStrictMode() { m_strictMode = true; }
-        bool strictMode() const { return m_strictMode; }
-        bool isValidStrictMode() const { return m_isValidStrictMode; }
-        bool shadowsArguments() const { return m_shadowsArguments; }
-        
-        void copyCapturedVariablesToVector(const IdentifierSet& capturedVariables, Vector<RefPtr<StringImpl> >& vector)
-        {
-            IdentifierSet::iterator end = capturedVariables.end();
-            for (IdentifierSet::iterator it = capturedVariables.begin(); it != end; ++it) {
-                if (m_declaredVariables.contains(*it))
-                    continue;
-                vector.append(*it);
-            }
-            vector.shrinkToFit();
-        }
-
-        void saveFunctionInfo(SourceProviderCacheItem* info)
-        {
-            ASSERT(m_isFunction);
-            info->usesEval = m_usesEval;
-            info->strictMode = m_strictMode;
-            info->needsFullActivation = m_needsFullActivation;
-            copyCapturedVariablesToVector(m_writtenVariables, info->writtenVariables);
-            copyCapturedVariablesToVector(m_usedVariables, info->usedVariables);
-        }
-
-        void restoreFunctionInfo(const SourceProviderCacheItem* info)
-        {
-            ASSERT(m_isFunction);
-            m_usesEval = info->usesEval;
-            m_strictMode = info->strictMode;
-            m_needsFullActivation = info->needsFullActivation;
-            unsigned size = info->usedVariables.size();
-            for (unsigned i = 0; i < size; ++i)
-                m_usedVariables.add(info->usedVariables[i]);
-            size = info->writtenVariables.size();
-            for (unsigned i = 0; i < size; ++i)
-                m_writtenVariables.add(info->writtenVariables[i]);
-        }
-
-    private:
-        JSGlobalData* m_globalData;
-        bool m_shadowsArguments : 1;
-        bool m_usesEval : 1;
-        bool m_needsFullActivation : 1;
-        bool m_allowsNewDecls : 1;
-        bool m_strictMode : 1;
-        bool m_isFunction : 1;
-        bool m_isFunctionBoundary : 1;
-        bool m_isValidStrictMode : 1;
-        int m_loopDepth;
-        int m_switchDepth;
-
-        typedef Vector<ScopeLabelInfo, 2> LabelStack;
-        OwnPtr<LabelStack> m_labels;
-        IdentifierSet m_declaredVariables;
-        IdentifierSet m_usedVariables;
-        IdentifierSet m_closedVariables;
-        IdentifierSet m_writtenVariables;
-    };
-
-    typedef Vector<Scope, 10> ScopeStack;
-
-    struct ScopeRef {
-        ScopeRef(ScopeStack* scopeStack, unsigned index)
-            : m_scopeStack(scopeStack)
-            , m_index(index)
-        {
-        }
-        Scope* operator->() { return &m_scopeStack->at(m_index); }
-        unsigned index() const { return m_index; }
-
-        bool hasContainingScope()
-        {
-            return m_index && !m_scopeStack->at(m_index).isFunctionBoundary();
-        }
-
-        ScopeRef containingScope()
-        {
-            ASSERT(hasContainingScope());
-            return ScopeRef(m_scopeStack, m_index - 1);
-        }
-
-    private:
-        ScopeStack* m_scopeStack;
-        unsigned m_index;
-    };
-
-    struct AutoPopScopeRef : public ScopeRef {
-        AutoPopScopeRef(JSParser* parser, ScopeRef scope)
-            : ScopeRef(scope)
-            , m_parser(parser)
-        {
-        }
-
-        ~AutoPopScopeRef()
-        {
-            if (m_parser)
-                m_parser->popScope(*this, false);
-        }
-
-        void setPopped()
-        {
-            m_parser = 0;
-        }
-
-    private:
-        JSParser* m_parser;
-    };
-
-    ScopeRef currentScope()
-    {
-        return ScopeRef(&m_scopeStack, m_scopeStack.size() - 1);
-    }
-    
-    ScopeRef pushScope()
-    {
-        bool isFunction = false;
-        bool isStrict = false;
-        if (!m_scopeStack.isEmpty()) {
-            isStrict = m_scopeStack.last().strictMode();
-            isFunction = m_scopeStack.last().isFunction();
-        }
-        m_scopeStack.append(Scope(m_globalData, isFunction, isStrict));
-        return currentScope();
-    }
-
-    bool popScopeInternal(ScopeRef& scope, bool shouldTrackClosedVariables)
-    {
-        ASSERT_UNUSED(scope, scope.index() == m_scopeStack.size() - 1);
-        ASSERT(m_scopeStack.size() > 1);
-        bool result = m_scopeStack[m_scopeStack.size() - 2].collectFreeVariables(&m_scopeStack.last(), shouldTrackClosedVariables);
-        m_scopeStack.removeLast();
-        return result;
-    }
-
-    bool popScope(ScopeRef& scope, bool shouldTrackClosedVariables)
-    {
-        return popScopeInternal(scope, shouldTrackClosedVariables);
-    }
-
-    bool popScope(AutoPopScopeRef& scope, bool shouldTrackClosedVariables)
-    {
-        scope.setPopped();
-        return popScopeInternal(scope, shouldTrackClosedVariables);
-    }
-
-    bool declareVariable(const Identifier* ident)
-    {
-        unsigned i = m_scopeStack.size() - 1;
-        ASSERT(i < m_scopeStack.size());
-        while (!m_scopeStack[i].allowsNewDecls()) {
-            i--;
-            ASSERT(i < m_scopeStack.size());
-        }
-        return m_scopeStack[i].declareVariable(ident);
-    }
-    
-    void declareWrite(const Identifier* ident)
-    {
-        if (!m_syntaxAlreadyValidated)
-            m_scopeStack.last().declareWrite(ident);
-    }
-
-    ScopeStack m_scopeStack;
-
-    const SourceProviderCacheItem* findCachedFunctionInfo(int openBracePos) 
-    {
-        return m_functionCache ? m_functionCache->get(openBracePos) : 0;
-    }
-
-    SourceProviderCache* m_functionCache;
-    const SourceCode* m_source;
-};
-
-UString jsParse(JSGlobalData* globalData, FunctionParameters* parameters, JSParserStrictness strictness, JSParserMode parserMode, const SourceCode* source)
-{
-    JSParser parser(globalData->lexer, globalData, parameters, strictness == JSParseStrict, parserMode == JSParseFunctionCode, source);
-    return parser.parseProgram();
-}
-
-JSParser::JSParser(Lexer* lexer, JSGlobalData* globalData, FunctionParameters* parameters, bool inStrictContext, bool isFunction, const SourceCode* source)
-    : m_lexer(lexer)
-    , m_stack(globalData->stack())
-    , m_error(false)
-    , m_errorMessage("Parse error")
-    , m_globalData(globalData)
-    , m_allowsIn(true)
-    , m_lastLine(0)
-    , m_lastTokenEnd(0)
-    , m_assignmentCount(0)
-    , m_nonLHSCount(0)
-    , m_syntaxAlreadyValidated(source->provider()->isValid())
-    , m_statementDepth(0)
-    , m_nonTrivialExpressionCount(0)
-    , m_lastIdentifier(0)
-    , m_functionCache(m_lexer->sourceProvider()->cache())
-    , m_source(source)
-{
-    ScopeRef scope = pushScope();
-    if (isFunction)
-        scope->setIsFunction();
-    if (inStrictContext)
-        scope->setStrictMode();
-    if (parameters) {
-        for (unsigned i = 0; i < parameters->size(); i++)
-            scope->declareParameter(&parameters->at(i));
-    }
-    next();
-    m_lexer->setLastLineNumber(tokenLine());
-}
-
-UString JSParser::parseProgram()
-{
-    unsigned oldFunctionCacheSize = m_functionCache ? m_functionCache->byteSize() : 0;
-    ASTBuilder context(m_globalData, m_lexer);
-    if (m_lexer->isReparsing())
-        m_statementDepth--;
-    ScopeRef scope = currentScope();
-    SourceElements* sourceElements = parseSourceElements<CheckForStrictMode>(context);
-    if (!sourceElements || !consume(EOFTOK))
-        return m_errorMessage;
-    IdentifierSet capturedVariables;
-    scope->getCapturedVariables(capturedVariables);
-    CodeFeatures features = context.features();
-    if (scope->strictMode())
-        features |= StrictModeFeature;
-    if (scope->shadowsArguments())
-        features |= ShadowsArgumentsFeature;
-    
-    unsigned functionCacheSize = m_functionCache ? m_functionCache->byteSize() : 0;
-    if (functionCacheSize != oldFunctionCacheSize)
-        m_lexer->sourceProvider()->notifyCacheSizeChanged(functionCacheSize - oldFunctionCacheSize);
-
-    m_globalData->parser->didFinishParsing(sourceElements, context.varDeclarations(), context.funcDeclarations(), features,
-                                           m_lastLine, context.numConstants(), capturedVariables);
-    return UString();
-}
-
-bool JSParser::allowAutomaticSemicolon()
-{
-    return match(CLOSEBRACE) || match(EOFTOK) || m_lexer->prevTerminator();
-}
-
-template <JSParser::SourceElementsMode mode, class TreeBuilder> TreeSourceElements JSParser::parseSourceElements(TreeBuilder& context)
-{
-    TreeSourceElements sourceElements = context.createSourceElements();
-    bool seenNonDirective = false;
-    const Identifier* directive = 0;
-    unsigned startOffset = m_token.m_info.startOffset;
-    unsigned oldLastLineNumber = m_lexer->lastLineNumber();
-    unsigned oldLineNumber = m_lexer->lineNumber();
-    bool hasSetStrict = false;
-    while (TreeStatement statement = parseStatement(context, directive)) {
-        if (mode == CheckForStrictMode && !seenNonDirective) {
-            if (directive) {
-                if (!hasSetStrict && m_globalData->propertyNames->useStrictIdentifier == *directive) {
-                    setStrictMode();
-                    hasSetStrict = true;
-                    failIfFalse(isValidStrictMode());
-                    m_lexer->setOffset(startOffset);
-                    next();
-                    m_lexer->setLastLineNumber(oldLastLineNumber);
-                    m_lexer->setLineNumber(oldLineNumber);
-                    failIfTrue(m_error);
-                    continue;
-                }
-            } else
-                seenNonDirective = true;
-        }
-        context.appendStatement(sourceElements, statement);
-    }
-
-    if (m_error)
-        fail();
-    return sourceElements;
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseVarDeclaration(TreeBuilder& context)
-{
-    ASSERT(match(VAR));
-    int start = tokenLine();
-    int end = 0;
-    int scratch;
-    const Identifier* scratch1 = 0;
-    TreeExpression scratch2 = 0;
-    int scratch3 = 0;
-    TreeExpression varDecls = parseVarDeclarationList(context, scratch, scratch1, scratch2, scratch3, scratch3, scratch3);
-    failIfTrue(m_error);
-    failIfFalse(autoSemiColon());
-
-    return context.createVarStatement(varDecls, start, end);
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseConstDeclaration(TreeBuilder& context)
-{
-    ASSERT(match(CONSTTOKEN));
-    int start = tokenLine();
-    int end = 0;
-    TreeConstDeclList constDecls = parseConstDeclarationList(context);
-    failIfTrue(m_error);
-    failIfFalse(autoSemiColon());
-    
-    return context.createConstStatement(constDecls, start, end);
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseDoWhileStatement(TreeBuilder& context)
-{
-    ASSERT(match(DO));
-    int startLine = tokenLine();
-    next();
-    const Identifier* unused = 0;
-    startLoop();
-    TreeStatement statement = parseStatement(context, unused);
-    endLoop();
-    failIfFalse(statement);
-    int endLine = tokenLine();
-    consumeOrFail(WHILE);
-    consumeOrFail(OPENPAREN);
-    TreeExpression expr = parseExpression(context);
-    failIfFalse(expr);
-    consumeOrFail(CLOSEPAREN);
-    if (match(SEMICOLON))
-        next(); // Always performs automatic semicolon insertion.
-    return context.createDoWhileStatement(statement, expr, startLine, endLine);
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseWhileStatement(TreeBuilder& context)
-{
-    ASSERT(match(WHILE));
-    int startLine = tokenLine();
-    next();
-    consumeOrFail(OPENPAREN);
-    TreeExpression expr = parseExpression(context);
-    failIfFalse(expr);
-    int endLine = tokenLine();
-    consumeOrFail(CLOSEPAREN);
-    const Identifier* unused = 0;
-    startLoop();
-    TreeStatement statement = parseStatement(context, unused);
-    endLoop();
-    failIfFalse(statement);
-    return context.createWhileStatement(expr, statement, startLine, endLine);
-}
-
-template <class TreeBuilder> TreeExpression JSParser::parseVarDeclarationList(TreeBuilder& context, int& declarations, const Identifier*& lastIdent, TreeExpression& lastInitializer, int& identStart, int& initStart, int& initEnd)
-{
-    TreeExpression varDecls = 0;
-    do {
-        declarations++;
-        next();
-        matchOrFail(IDENT);
-
-        int varStart = tokenStart();
-        identStart = varStart;
-        const Identifier* name = m_token.m_data.ident;
-        lastIdent = name;
-        next();
-        bool hasInitializer = match(EQUAL);
-        failIfFalseIfStrictWithNameAndMessage(declareVariable(name), "Cannot declare a variable named", name->impl(), "in strict mode.");
-        context.addVar(name, (hasInitializer || (!m_allowsIn && match(INTOKEN))) ? DeclarationStacks::HasInitializer : 0);
-        if (hasInitializer) {
-            int varDivot = tokenStart() + 1;
-            initStart = tokenStart();
-            next(TreeBuilder::DontBuildStrings); // consume '='
-            int initialAssignments = m_assignmentCount;
-            TreeExpression initializer = parseAssignmentExpression(context);
-            initEnd = lastTokenEnd();
-            lastInitializer = initializer;
-            failIfFalse(initializer);
-
-            TreeExpression node = context.createAssignResolve(*name, initializer, initialAssignments != m_assignmentCount, varStart, varDivot, lastTokenEnd());
-            if (!varDecls)
-                varDecls = node;
-            else
-                varDecls = context.combineCommaNodes(varDecls, node);
-        }
-    } while (match(COMMA));
-    return varDecls;
-}
-
-template <class TreeBuilder> TreeConstDeclList JSParser::parseConstDeclarationList(TreeBuilder& context)
-{
-    failIfTrue(strictMode());
-    TreeConstDeclList constDecls = 0;
-    TreeConstDeclList tail = 0;
-    do {
-        next();
-        matchOrFail(IDENT);
-        const Identifier* name = m_token.m_data.ident;
-        next();
-        bool hasInitializer = match(EQUAL);
-        declareVariable(name);
-        context.addVar(name, DeclarationStacks::IsConstant | (hasInitializer ? DeclarationStacks::HasInitializer : 0));
-        TreeExpression initializer = 0;
-        if (hasInitializer) {
-            next(TreeBuilder::DontBuildStrings); // consume '='
-            initializer = parseAssignmentExpression(context);
-        }
-        tail = context.appendConstDecl(tail, name, initializer);
-        if (!constDecls)
-            constDecls = tail;
-    } while (match(COMMA));
-    return constDecls;
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseForStatement(TreeBuilder& context)
-{
-    ASSERT(match(FOR));
-    int startLine = tokenLine();
-    next();
-    consumeOrFail(OPENPAREN);
-    int nonLHSCount = m_nonLHSCount;
-    int declarations = 0;
-    int declsStart = 0;
-    int declsEnd = 0;
-    TreeExpression decls = 0;
-    bool hasDeclaration = false;
-    if (match(VAR)) {
-        /*
-         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 initStart = 0;
-        int initEnd = 0;
-        decls = parseVarDeclarationList(context, declarations, forInTarget, forInInitializer, declsStart, initStart, initEnd);
-        m_allowsIn = true;
-        if (m_error)
-            fail();
-
-        // Remainder of a standard for loop is handled identically
-        if (match(SEMICOLON))
-            goto standardForLoop;
-
-        failIfFalse(declarations == 1);
-
-        // Handle for-in with var declaration
-        int inLocation = tokenStart();
-        consumeOrFail(INTOKEN);
-
-        TreeExpression expr = parseExpression(context);
-        failIfFalse(expr);
-        int exprEnd = lastTokenEnd();
-
-        int endLine = tokenLine();
-        consumeOrFail(CLOSEPAREN);
-
-        const Identifier* unused = 0;
-        startLoop();
-        TreeStatement statement = parseStatement(context, unused);
-        endLoop();
-        failIfFalse(statement);
-
-        return context.createForInLoop(forInTarget, forInInitializer, expr, statement, declsStart, inLocation, exprEnd, initStart, initEnd, startLine, endLine);
-    }
-
-    if (!match(SEMICOLON)) {
-        m_allowsIn = false;
-        declsStart = tokenStart();
-        decls = parseExpression(context);
-        declsEnd = lastTokenEnd();
-        m_allowsIn = true;
-        failIfFalse(decls);
-    }
-
-    if (match(SEMICOLON)) {
-    standardForLoop:
-        // Standard for loop
-        next();
-        TreeExpression condition = 0;
-
-        if (!match(SEMICOLON)) {
-            condition = parseExpression(context);
-            failIfFalse(condition);
-        }
-        consumeOrFail(SEMICOLON);
-
-        TreeExpression increment = 0;
-        if (!match(CLOSEPAREN)) {
-            increment = parseExpression(context);
-            failIfFalse(increment);
-        }
-        int endLine = tokenLine();
-        consumeOrFail(CLOSEPAREN);
-        const Identifier* unused = 0;
-        startLoop();
-        TreeStatement statement = parseStatement(context, unused);
-        endLoop();
-        failIfFalse(statement);
-        return context.createForLoop(decls, condition, increment, statement, hasDeclaration, startLine, endLine);
-    }
-
-    // For-in loop
-    failIfFalse(nonLHSCount == m_nonLHSCount);
-    consumeOrFail(INTOKEN);
-    TreeExpression expr = parseExpression(context);
-    failIfFalse(expr);
-    int exprEnd = lastTokenEnd();
-    int endLine = tokenLine();
-    consumeOrFail(CLOSEPAREN);
-    const Identifier* unused = 0;
-    startLoop();
-    TreeStatement statement = parseStatement(context, unused);
-    endLoop();
-    failIfFalse(statement);
-    
-    return context.createForInLoop(decls, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine);
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseBreakStatement(TreeBuilder& context)
-{
-    ASSERT(match(BREAK));
-    int startCol = tokenStart();
-    int endCol = tokenEnd();
-    int startLine = tokenLine();
-    int endLine = tokenLine();
-    next();
-
-    if (autoSemiColon()) {
-        failIfFalseWithMessage(breakIsValid(), "'break' is only valid inside a switch or loop statement");
-        return context.createBreakStatement(startCol, endCol, startLine, endLine);
-    }
-    matchOrFail(IDENT);
-    const Identifier* ident = m_token.m_data.ident;
-    failIfFalseWithNameAndMessage(getLabel(ident), "Label", ident->impl(), "is not defined");
-    endCol = tokenEnd();
-    endLine = tokenLine();
-    next();
-    failIfFalse(autoSemiColon());
-    return context.createBreakStatement(ident, startCol, endCol, startLine, endLine);
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseContinueStatement(TreeBuilder& context)
-{
-    ASSERT(match(CONTINUE));
-    int startCol = tokenStart();
-    int endCol = tokenEnd();
-    int startLine = tokenLine();
-    int endLine = tokenLine();
-    next();
-
-    if (autoSemiColon()) {
-        failIfFalseWithMessage(continueIsValid(), "'continue' is only valid inside a loop statement");
-        return context.createContinueStatement(startCol, endCol, startLine, endLine);
-    }
-    matchOrFail(IDENT);
-    const Identifier* ident = m_token.m_data.ident;
-    ScopeLabelInfo* label = getLabel(ident);
-    failIfFalseWithNameAndMessage(label, "Label", ident->impl(), "is not defined");
-    failIfFalseWithMessage(label->m_isLoop, "'continue' is only valid inside a loop statement");
-    endCol = tokenEnd();
-    endLine = tokenLine();
-    next();
-    failIfFalse(autoSemiColon());
-    return context.createContinueStatement(ident, startCol, endCol, startLine, endLine);
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseReturnStatement(TreeBuilder& context)
-{
-    ASSERT(match(RETURN));
-    failIfFalse(currentScope()->isFunction());
-    int startLine = tokenLine();
-    int endLine = startLine;
-    int start = tokenStart();
-    int end = tokenEnd();
-    next();
-    // We do the auto semicolon check before attempting to parse an expression
-    // as we need to ensure the a line break after the return correctly terminates
-    // the statement
-    if (match(SEMICOLON))
-        endLine  = tokenLine();
-    if (autoSemiColon())
-        return context.createReturnStatement(0, start, end, startLine, endLine);
-    TreeExpression expr = parseExpression(context);
-    failIfFalse(expr);
-    end = lastTokenEnd();
-    if (match(SEMICOLON))
-        endLine  = tokenLine();
-    failIfFalse(autoSemiColon());
-    return context.createReturnStatement(expr, start, end, startLine, endLine);
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseThrowStatement(TreeBuilder& context)
-{
-    ASSERT(match(THROW));
-    int eStart = tokenStart();
-    int startLine = tokenLine();
-    next();
-    
-    failIfTrue(autoSemiColon());
-
-    TreeExpression expr = parseExpression(context);
-    failIfFalse(expr);
-    int eEnd = lastTokenEnd();
-    int endLine = tokenLine();
-    failIfFalse(autoSemiColon());
-
-    return context.createThrowStatement(expr, eStart, eEnd, startLine, endLine);
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseWithStatement(TreeBuilder& context)
-{
-    ASSERT(match(WITH));
-    failIfTrueWithMessage(strictMode(), "'with' statements are not valid in strict mode");
-    currentScope()->setNeedsFullActivation();
-    int startLine = tokenLine();
-    next();
-    consumeOrFail(OPENPAREN);
-    int start = tokenStart();
-    TreeExpression expr = parseExpression(context);
-    failIfFalse(expr);
-    int end = lastTokenEnd();
-
-    int endLine = tokenLine();
-    consumeOrFail(CLOSEPAREN);
-    const Identifier* unused = 0;
-    TreeStatement statement = parseStatement(context, unused);
-    failIfFalse(statement);
-
-    return context.createWithStatement(expr, statement, start, end, startLine, endLine);
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseSwitchStatement(TreeBuilder& context)
-{
-    ASSERT(match(SWITCH));
-    int startLine = tokenLine();
-    next();
-    consumeOrFail(OPENPAREN);
-    TreeExpression expr = parseExpression(context);
-    failIfFalse(expr);
-    int endLine = tokenLine();
-    consumeOrFail(CLOSEPAREN);
-    consumeOrFail(OPENBRACE);
-    startSwitch();
-    TreeClauseList firstClauses = parseSwitchClauses(context);
-    failIfTrue(m_error);
-
-    TreeClause defaultClause = parseSwitchDefaultClause(context);
-    failIfTrue(m_error);
-
-    TreeClauseList secondClauses = parseSwitchClauses(context);
-    failIfTrue(m_error);
-    endSwitch();
-    consumeOrFail(CLOSEBRACE);
-
-    return context.createSwitchStatement(expr, firstClauses, defaultClause, secondClauses, startLine, endLine);
-
-}
-
-template <class TreeBuilder> TreeClauseList JSParser::parseSwitchClauses(TreeBuilder& context)
-{
-    if (!match(CASE))
-        return 0;
-    next();
-    TreeExpression condition = parseExpression(context);
-    failIfFalse(condition);
-    consumeOrFail(COLON);
-    TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);
-    failIfFalse(statements);
-    TreeClause clause = context.createClause(condition, statements);
-    TreeClauseList clauseList = context.createClauseList(clause);
-    TreeClauseList tail = clauseList;
-
-    while (match(CASE)) {
-        next();
-        TreeExpression condition = parseExpression(context);
-        failIfFalse(condition);
-        consumeOrFail(COLON);
-        TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);
-        failIfFalse(statements);
-        clause = context.createClause(condition, statements);
-        tail = context.createClauseList(tail, clause);
-    }
-    return clauseList;
-}
-
-template <class TreeBuilder> TreeClause JSParser::parseSwitchDefaultClause(TreeBuilder& context)
-{
-    if (!match(DEFAULT))
-        return 0;
-    next();
-    consumeOrFail(COLON);
-    TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);
-    failIfFalse(statements);
-    return context.createClause(0, statements);
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseTryStatement(TreeBuilder& context)
-{
-    ASSERT(match(TRY));
-    TreeStatement tryBlock = 0;
-    const Identifier* ident = &m_globalData->propertyNames->nullIdentifier;
-    bool catchHasEval = false;
-    TreeStatement catchBlock = 0;
-    TreeStatement finallyBlock = 0;
-    int firstLine = tokenLine();
-    next();
-    matchOrFail(OPENBRACE);
-
-    tryBlock = parseBlockStatement(context);
-    failIfFalse(tryBlock);
-    int lastLine = m_lastLine;
-
-    if (match(CATCH)) {
-        currentScope()->setNeedsFullActivation();
-        next();
-        consumeOrFail(OPENPAREN);
-        matchOrFail(IDENT);
-        ident = m_token.m_data.ident;
-        next();
-        AutoPopScopeRef catchScope(this, pushScope());
-        failIfFalseIfStrictWithNameAndMessage(catchScope->declareVariable(ident), "Cannot declare a variable named", ident->impl(), "in strict mode");
-        catchScope->preventNewDecls();
-        consumeOrFail(CLOSEPAREN);
-        matchOrFail(OPENBRACE);
-        int initialEvalCount = context.evalCount();
-        catchBlock = parseBlockStatement(context);
-        failIfFalseWithMessage(catchBlock, "'try' must have a catch or finally block");
-        catchHasEval = initialEvalCount != context.evalCount();
-        failIfFalse(popScope(catchScope, TreeBuilder::NeedsFreeVariableInfo));
-    }
-
-    if (match(FINALLY)) {
-        next();
-        matchOrFail(OPENBRACE);
-        finallyBlock = parseBlockStatement(context);
-        failIfFalse(finallyBlock);
-    }
-    failIfFalse(catchBlock || finallyBlock);
-    return context.createTryStatement(tryBlock, ident, catchHasEval, catchBlock, finallyBlock, firstLine, lastLine);
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseDebuggerStatement(TreeBuilder& context)
-{
-    ASSERT(match(DEBUGGER));
-    int startLine = tokenLine();
-    int endLine = startLine;
-    next();
-    if (match(SEMICOLON))
-        startLine = tokenLine();
-    failIfFalse(autoSemiColon());
-    return context.createDebugger(startLine, endLine);
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseBlockStatement(TreeBuilder& context)
-{
-    ASSERT(match(OPENBRACE));
-    int start = tokenLine();
-    next();
-    if (match(CLOSEBRACE)) {
-        next();
-        return context.createBlockStatement(0, start, m_lastLine);
-    }
-    TreeSourceElements subtree = parseSourceElements<DontCheckForStrictMode>(context);
-    failIfFalse(subtree);
-    matchOrFail(CLOSEBRACE);
-    next();
-    return context.createBlockStatement(subtree, start, m_lastLine);
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseStatement(TreeBuilder& context, const Identifier*& directive)
-{
-    DepthManager statementDepth(&m_statementDepth);
-    m_statementDepth++;
-    directive = 0;
-    int nonTrivialExpressionCount = 0;
-    failIfStackOverflow();
-    switch (m_token.m_type) {
-    case OPENBRACE:
-        return parseBlockStatement(context);
-    case VAR:
-        return parseVarDeclaration(context);
-    case CONSTTOKEN:
-        return parseConstDeclaration(context);
-    case FUNCTION:
-        failIfFalseIfStrictWithMessage(m_statementDepth == 1, "Functions cannot be declared in a nested block in strict mode");
-        return parseFunctionDeclaration(context);
-    case SEMICOLON:
-        next();
-        return context.createEmptyStatement();
-    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;
-        nonTrivialExpressionCount = m_nonTrivialExpressionCount;
-    default:
-        TreeStatement exprStatement = parseExpressionStatement(context);
-        if (directive && nonTrivialExpressionCount != m_nonTrivialExpressionCount)
-            directive = 0;
-        return exprStatement;
-    }
-}
-
-template <class TreeBuilder> TreeFormalParameterList JSParser::parseFormalParameters(TreeBuilder& context)
-{
-    matchOrFail(IDENT);
-    failIfFalseIfStrictWithNameAndMessage(declareParameter(m_token.m_data.ident), "Cannot declare a parameter named", m_token.m_data.ident->impl(), " in strict mode");
-    TreeFormalParameterList list = context.createFormalParameterList(*m_token.m_data.ident);
-    TreeFormalParameterList tail = list;
-    next();
-    while (match(COMMA)) {
-        next();
-        matchOrFail(IDENT);
-        const Identifier* ident = m_token.m_data.ident;
-        failIfFalseIfStrictWithNameAndMessage(declareParameter(ident), "Cannot declare a parameter named", ident->impl(), "in strict mode");
-        next();
-        tail = context.createFormalParameterList(tail, *ident);
-    }
-    return list;
-}
-
-template <class TreeBuilder> TreeFunctionBody JSParser::parseFunctionBody(TreeBuilder& context)
-{
-    if (match(CLOSEBRACE))
-        return context.createFunctionBody(strictMode());
-    DepthManager statementDepth(&m_statementDepth);
-    m_statementDepth = 0;
-    typename TreeBuilder::FunctionBodyBuilder bodyBuilder(m_globalData, m_lexer);
-    failIfFalse(parseSourceElements<CheckForStrictMode>(bodyBuilder));
-    return context.createFunctionBody(strictMode());
-}
-
-template <JSParser::FunctionRequirements requirements, bool nameIsInContainingScope, class TreeBuilder> bool JSParser::parseFunctionInfo(TreeBuilder& context, const Identifier*& name, TreeFormalParameterList& parameters, TreeFunctionBody& body, int& openBracePos, int& closeBracePos, int& bodyStartLine)
-{
-    AutoPopScopeRef functionScope(this, pushScope());
-    functionScope->setIsFunction();
-    if (match(IDENT)) {
-        name = m_token.m_data.ident;
-        failIfTrueWithMessage(*name == m_globalData->propertyNames->underscoreProto, "Cannot name a function __proto__");
-        next();
-        if (!nameIsInContainingScope)
-            failIfFalseIfStrict(functionScope->declareVariable(name));
-    } else if (requirements == FunctionNeedsName)
-        return false;
-    consumeOrFail(OPENPAREN);
-    if (!match(CLOSEPAREN)) {
-        parameters = parseFormalParameters(context);
-        failIfFalse(parameters);
-    }
-    consumeOrFail(CLOSEPAREN);
-    matchOrFail(OPENBRACE);
-
-    openBracePos = m_token.m_data.intValue;
-    bodyStartLine = tokenLine();
-
-    // If we know about this function already, we can use the cached info and skip the parser to the end of the function.
-    if (const SourceProviderCacheItem* cachedInfo = TreeBuilder::CanUseFunctionCache ? findCachedFunctionInfo(openBracePos) : 0) {
-        // If we're in a strict context, the cached function info must say it was strict too.
-        ASSERT(!strictMode() || cachedInfo->strictMode);
-        body = context.createFunctionBody(cachedInfo->strictMode);
-
-        functionScope->restoreFunctionInfo(cachedInfo);
-        failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo));
-
-        closeBracePos = cachedInfo->closeBracePos;
-        m_token = cachedInfo->closeBraceToken();
-        m_lexer->setOffset(m_token.m_info.endOffset);
-        m_lexer->setLineNumber(m_token.m_info.line);
-
-        next();
-        return true;
-    }
-
-    next();
-
-    body = parseFunctionBody(context);
-    failIfFalse(body);
-    if (functionScope->strictMode() && name) {
-        failIfTrueWithNameAndMessage(m_globalData->propertyNames->arguments == *name, "Function name", name->impl(), "is not valid in strict mode");
-        failIfTrueWithNameAndMessage(m_globalData->propertyNames->eval == *name, "Function name", name->impl(), "is not valid in strict mode");
-    }
-    closeBracePos = m_token.m_data.intValue;
-    
-    // Cache the tokenizer state and the function scope the first time the function is parsed.
-    // Any future reparsing can then skip the function.
-    static const int minimumFunctionLengthToCache = 64;
-    OwnPtr<SourceProviderCacheItem> newInfo;
-    int functionLength = closeBracePos - openBracePos;
-    if (TreeBuilder::CanUseFunctionCache && m_functionCache && functionLength > minimumFunctionLengthToCache) {
-        newInfo = adoptPtr(new SourceProviderCacheItem(m_token.m_info.line, closeBracePos));
-        functionScope->saveFunctionInfo(newInfo.get());
-    }
-    
-    failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo));
-    matchOrFail(CLOSEBRACE);
-
-    if (newInfo) {
-        unsigned approximateByteSize = newInfo->approximateByteSize();
-        m_functionCache->add(openBracePos, newInfo.release(), approximateByteSize);
-    }
-
-    next();
-    return true;
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseFunctionDeclaration(TreeBuilder& context)
-{
-    ASSERT(match(FUNCTION));
-    next();
-    const Identifier* name = 0;
-    TreeFormalParameterList parameters = 0;
-    TreeFunctionBody body = 0;
-    int openBracePos = 0;
-    int closeBracePos = 0;
-    int bodyStartLine = 0;
-    failIfFalse((parseFunctionInfo<FunctionNeedsName, true>(context, name, parameters, body, openBracePos, closeBracePos, bodyStartLine)));
-    failIfFalse(name);
-    failIfFalseIfStrict(declareVariable(name));
-    return context.createFuncDeclStatement(name, body, parameters, openBracePos, closeBracePos, bodyStartLine, m_lastLine);
-}
-
-struct LabelInfo {
-    LabelInfo(const Identifier* ident, int start, int end)
-        : m_ident(ident)
-        , m_start(start)
-        , m_end(end)
-    {
-    }
-
-    const Identifier* m_ident;
-    int m_start;
-    int m_end;
-};
-
-template <class TreeBuilder> TreeStatement JSParser::parseExpressionOrLabelStatement(TreeBuilder& context)
-{
-
-    /* Expression and Label statements are ambiguous at LL(1), so we have a
-     * special case that looks for a colon as the next character in the input.
-     */
-    Vector<LabelInfo> labels;
-
-    do {
-        int start = tokenStart();
-        int startLine = tokenLine();
-        if (!nextTokenIsColon()) {
-            // If we hit this path we're making a expression statement, which
-            // by definition can't make use of continue/break so we can just
-            // ignore any labels we might have accumulated.
-            TreeExpression expression = parseExpression(context);
-            failIfFalse(expression);
-            failIfFalse(autoSemiColon());
-            return context.createExprStatement(expression, startLine, m_lastLine);
-        }
-        const Identifier* ident = m_token.m_data.ident;
-        int end = tokenEnd();
-        next();
-        consumeOrFail(COLON);
-        if (!m_syntaxAlreadyValidated) {
-            // This is O(N^2) over the current list of consecutive labels, but I
-            // have never seen more than one label in a row in the real world.
-            for (size_t i = 0; i < labels.size(); i++)
-                failIfTrue(ident->impl() == labels[i].m_ident->impl());
-            failIfTrue(getLabel(ident));
-            labels.append(LabelInfo(ident, start, end));
-        }
-    } while (match(IDENT));
-    bool isLoop = false;
-    switch (m_token.m_type) {
-    case FOR:
-    case WHILE:
-    case DO:
-        isLoop = true;
-        break;
-
-    default:
-        break;
-    }
-    const Identifier* unused = 0;
-    if (!m_syntaxAlreadyValidated) {
-        for (size_t i = 0; i < labels.size(); i++)
-            pushLabel(labels[i].m_ident, isLoop);
-    }
-    TreeStatement statement = parseStatement(context, unused);
-    if (!m_syntaxAlreadyValidated) {
-        for (size_t i = 0; i < labels.size(); i++)
-            popLabel();
-    }
-    failIfFalse(statement);
-    for (size_t i = 0; i < labels.size(); i++) {
-        const LabelInfo& info = labels[labels.size() - i - 1];
-        statement = context.createLabelStatement(info.m_ident, statement, info.m_start, info.m_end);
-    }
-    return statement;
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseExpressionStatement(TreeBuilder& context)
-{
-    int startLine = tokenLine();
-    TreeExpression expression = parseExpression(context);
-    failIfFalse(expression);
-    failIfFalse(autoSemiColon());
-    return context.createExprStatement(expression, startLine, m_lastLine);
-}
-
-template <class TreeBuilder> TreeStatement JSParser::parseIfStatement(TreeBuilder& context)
-{
-    ASSERT(match(IF));
-
-    int start = tokenLine();
-    next();
-
-    consumeOrFail(OPENPAREN);
-
-    TreeExpression condition = parseExpression(context);
-    failIfFalse(condition);
-    int end = tokenLine();
-    consumeOrFail(CLOSEPAREN);
-
-    const Identifier* unused = 0;
-    TreeStatement trueBlock = parseStatement(context, unused);
-    failIfFalse(trueBlock);
-
-    if (!match(ELSE))
-        return context.createIfStatement(condition, trueBlock, start, end);
-    
-    Vector<TreeExpression> exprStack;
-    Vector<pair<int, int> > posStack;
-    Vector<TreeStatement> statementStack;
-    bool trailingElse = false;
-    do {
-        next();
-        if (!match(IF)) {
-            const Identifier* unused = 0;
-            TreeStatement block = parseStatement(context, unused);
-            failIfFalse(block);
-            statementStack.append(block);
-            trailingElse = true;
-            break;
-        }
-        int innerStart = tokenLine();
-        next();
-        
-        consumeOrFail(OPENPAREN);
-        
-        TreeExpression innerCondition = parseExpression(context);
-        failIfFalse(innerCondition);
-        int innerEnd = tokenLine();
-        consumeOrFail(CLOSEPAREN);
-        const Identifier* unused = 0;
-        TreeStatement innerTrueBlock = parseStatement(context, unused);
-        failIfFalse(innerTrueBlock);     
-        exprStack.append(innerCondition);
-        posStack.append(make_pair(innerStart, innerEnd));
-        statementStack.append(innerTrueBlock);
-    } while (match(ELSE));
-
-    if (!trailingElse) {
-        TreeExpression condition = exprStack.last();
-        exprStack.removeLast();
-        TreeStatement trueBlock = statementStack.last();
-        statementStack.removeLast();
-        pair<int, int> pos = posStack.last();
-        posStack.removeLast();
-        statementStack.append(context.createIfStatement(condition, trueBlock, pos.first, pos.second));
-    }
-
-    while (!exprStack.isEmpty()) {
-        TreeExpression condition = exprStack.last();
-        exprStack.removeLast();
-        TreeStatement falseBlock = statementStack.last();
-        statementStack.removeLast();
-        TreeStatement trueBlock = statementStack.last();
-        statementStack.removeLast();
-        pair<int, int> pos = posStack.last();
-        posStack.removeLast();
-        statementStack.append(context.createIfStatement(condition, trueBlock, falseBlock, pos.first, pos.second));
-    }
-    
-    return context.createIfStatement(condition, trueBlock, statementStack.last(), start, end);
-}
-
-template <class TreeBuilder> TreeExpression JSParser::parseExpression(TreeBuilder& context)
-{
-    failIfStackOverflow();
-    TreeExpression node = parseAssignmentExpression(context);
-    failIfFalse(node);
-    if (!match(COMMA))
-        return node;
-    next();
-    m_nonTrivialExpressionCount++;
-    m_nonLHSCount++;
-    TreeExpression right = parseAssignmentExpression(context);
-    failIfFalse(right);
-    typename TreeBuilder::Comma commaNode = context.createCommaExpr(node, right);
-    while (match(COMMA)) {
-        next(TreeBuilder::DontBuildStrings);
-        right = parseAssignmentExpression(context);
-        failIfFalse(right);
-        context.appendToComma(commaNode, right);
-    }
-    return commaNode;
-}
-
-
-template <typename TreeBuilder> TreeExpression JSParser::parseAssignmentExpression(TreeBuilder& context)
-{
-    failIfStackOverflow();
-    int start = tokenStart();
-    int initialAssignmentCount = m_assignmentCount;
-    int initialNonLHSCount = m_nonLHSCount;
-    TreeExpression lhs = parseConditionalExpression(context);
-    failIfFalse(lhs);
-    if (initialNonLHSCount != m_nonLHSCount)
-        return lhs;
-
-    int assignmentStack = 0;
-    Operator op;
-    bool hadAssignment = false;
-    while (true) {
-        switch (m_token.m_type) {
-        case EQUAL: op = OpEqual; break;
-        case PLUSEQUAL: op = OpPlusEq; break;
-        case MINUSEQUAL: op = OpMinusEq; break;
-        case MULTEQUAL: op = OpMultEq; break;
-        case DIVEQUAL: op = OpDivEq; break;
-        case LSHIFTEQUAL: op = OpLShift; break;
-        case RSHIFTEQUAL: op = OpRShift; break;
-        case URSHIFTEQUAL: op = OpURShift; break;
-        case ANDEQUAL: op = OpAndEq; break;
-        case XOREQUAL: op = OpXOrEq; break;
-        case OREQUAL: op = OpOrEq; break;
-        case MODEQUAL: op = OpModEq; break;
-        default:
-            goto end;
-        }
-        m_nonTrivialExpressionCount++;
-        hadAssignment = true;
-        context.assignmentStackAppend(assignmentStack, lhs, start, tokenStart(), m_assignmentCount, op);
-        start = tokenStart();
-        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");
-            declareWrite(m_lastIdentifier);
-            m_lastIdentifier = 0;
-        }
-        lhs = parseConditionalExpression(context);
-        failIfFalse(lhs);
-        if (initialNonLHSCount != m_nonLHSCount)
-            break;
-    }
-end:
-    if (hadAssignment)
-        m_nonLHSCount++;
-
-    if (!TreeBuilder::CreatesAST)
-        return lhs;
-
-    while (assignmentStack)
-        lhs = context.createAssignment(assignmentStack, lhs, initialAssignmentCount, m_assignmentCount, lastTokenEnd());
-
-    return lhs;
-}
-
-template <class TreeBuilder> TreeExpression JSParser::parseConditionalExpression(TreeBuilder& context)
-{
-    TreeExpression cond = parseBinaryExpression(context);
-    failIfFalse(cond);
-    if (!match(QUESTION))
-        return cond;
-    m_nonTrivialExpressionCount++;
-    m_nonLHSCount++;
-    next(TreeBuilder::DontBuildStrings);
-    TreeExpression lhs = parseAssignmentExpression(context);
-    consumeOrFailWithFlags(COLON, TreeBuilder::DontBuildStrings);
-
-    TreeExpression rhs = parseAssignmentExpression(context);
-    failIfFalse(rhs);
-    return context.createConditionalExpr(cond, lhs, rhs);
-}
-
-ALWAYS_INLINE static bool isUnaryOp(JSTokenType token)
-{
-    return token & UnaryOpTokenFlag;
-}
-
-int JSParser::isBinaryOperator(JSTokenType token)
-{
-    if (m_allowsIn)
-        return token & (BinaryOpTokenPrecedenceMask << BinaryOpTokenAllowsInPrecedenceAdditionalShift);
-    return token & BinaryOpTokenPrecedenceMask;
-}
-
-template <class TreeBuilder> TreeExpression JSParser::parseBinaryExpression(TreeBuilder& context)
-{
-
-    int operandStackDepth = 0;
-    int operatorStackDepth = 0;
-    typename TreeBuilder::BinaryExprContext binaryExprContext(context);
-    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);
-        int precedence = isBinaryOperator(m_token.m_type);
-        if (!precedence)
-            break;
-        m_nonTrivialExpressionCount++;
-        m_nonLHSCount++;
-        int operatorToken = m_token.m_type;
-        next(TreeBuilder::DontBuildStrings);
-
-        while (operatorStackDepth &&  context.operatorStackHasHigherPrecedence(operatorStackDepth, precedence)) {
-            ASSERT(operandStackDepth > 1);
-
-            typename TreeBuilder::BinaryOperand rhs = context.getFromOperandStack(-1);
-            typename TreeBuilder::BinaryOperand lhs = context.getFromOperandStack(-2);
-            context.shrinkOperandStackBy(operandStackDepth, 2);
-            context.appendBinaryOperation(operandStackDepth, operatorStackDepth, lhs, rhs);
-            context.operatorStackPop(operatorStackDepth);
-        }
-        context.operatorStackAppend(operatorStackDepth, operatorToken, precedence);
-    }
-    while (operatorStackDepth) {
-        ASSERT(operandStackDepth > 1);
-
-        typename TreeBuilder::BinaryOperand rhs = context.getFromOperandStack(-1);
-        typename TreeBuilder::BinaryOperand lhs = context.getFromOperandStack(-2);
-        context.shrinkOperandStackBy(operandStackDepth, 2);
-        context.appendBinaryOperation(operandStackDepth, operatorStackDepth, lhs, rhs);
-        context.operatorStackPop(operatorStackDepth);
-    }
-    return context.popOperandStack(operandStackDepth);
-}
-
-
-template <bool complete, class TreeBuilder> TreeProperty JSParser::parseProperty(TreeBuilder& context)
-{
-    bool wasIdent = false;
-    switch (m_token.m_type) {
-    namedProperty:
-    case IDENT:
-        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)))
-            nextExpectIdentifier(Lexer::IgnoreReservedWords);
-        else
-            nextExpectIdentifier(Lexer::IgnoreReservedWords | TreeBuilder::DontBuildKeywords);
-
-        if (match(COLON)) {
-            next();
-            TreeExpression node = parseAssignmentExpression(context);
-            failIfFalse(node);
-            return context.template createProperty<complete>(ident, node, PropertyNode::Constant);
-        }
-        failIfFalse(wasIdent);
-        matchOrFail(IDENT);
-        const Identifier* accessorName = 0;
-        TreeFormalParameterList parameters = 0;
-        TreeFunctionBody body = 0;
-        int openBracePos = 0;
-        int closeBracePos = 0;
-        int bodyStartLine = 0;
-        PropertyNode::Type type;
-        if (*ident == m_globalData->propertyNames->get)
-            type = PropertyNode::Getter;
-        else if (*ident == m_globalData->propertyNames->set)
-            type = PropertyNode::Setter;
-        else
-            fail();
-        failIfFalse((parseFunctionInfo<FunctionNeedsName, false>(context, accessorName, parameters, body, openBracePos, closeBracePos, bodyStartLine)));
-        return context.template createGetterOrSetterProperty<complete>(type, accessorName, parameters, body, openBracePos, closeBracePos, bodyStartLine, m_lastLine);
-    }
-    case NUMBER: {
-        double propertyName = m_token.m_data.doubleValue;
-        next();
-        consumeOrFail(COLON);
-        TreeExpression node = parseAssignmentExpression(context);
-        failIfFalse(node);
-        return context.template createProperty<complete>(m_globalData, propertyName, node, PropertyNode::Constant);
-    }
-    default:
-        failIfFalse(m_token.m_type & KeywordTokenFlag);
-        goto namedProperty;
-    }
-}
-
-template <class TreeBuilder> TreeExpression JSParser::parseObjectLiteral(TreeBuilder& context)
-{
-    int startOffset = m_token.m_data.intValue;
-    consumeOrFailWithFlags(OPENBRACE, TreeBuilder::DontBuildStrings);
-
-    if (match(CLOSEBRACE)) {
-        next();
-        return context.createObjectLiteral();
-    }
-
-    TreeProperty property = parseProperty<false>(context);
-    failIfFalse(property);
-    if (!m_syntaxAlreadyValidated && context.getType(property) != PropertyNode::Constant) {
-        m_lexer->setOffset(startOffset);
-        next();
-        return parseStrictObjectLiteral(context);
-    }
-    TreePropertyList propertyList = context.createPropertyList(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;
-        property = parseProperty<false>(context);
-        failIfFalse(property);
-        if (!m_syntaxAlreadyValidated && context.getType(property) != PropertyNode::Constant) {
-            m_lexer->setOffset(startOffset);
-            next();
-            return parseStrictObjectLiteral(context);
-        }
-        tail = context.createPropertyList(property, tail);
-    }
-
-    consumeOrFail(CLOSEBRACE);
-
-    return context.createObjectLiteral(propertyList);
-}
-
-template <class TreeBuilder> TreeExpression JSParser::parseStrictObjectLiteral(TreeBuilder& context)
-{
-    consumeOrFail(OPENBRACE);
-    
-    if (match(CLOSEBRACE)) {
-        next();
-        return context.createObjectLiteral();
-    }
-    
-    TreeProperty property = parseProperty<true>(context);
-    failIfFalse(property);
-    
-    typedef HashMap<RefPtr<StringImpl>, unsigned, IdentifierRepHash> ObjectValidationMap;
-    ObjectValidationMap objectValidator;
-    // Add the first property
-    if (!m_syntaxAlreadyValidated)
-        objectValidator.add(context.getName(property).impl(), context.getType(property));
-    
-    TreePropertyList propertyList = context.createPropertyList(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;
-        property = parseProperty<true>(context);
-        failIfFalse(property);
-        if (!m_syntaxAlreadyValidated) {
-            std::pair<ObjectValidationMap::iterator, bool> propertyEntryIter = objectValidator.add(context.getName(property).impl(), context.getType(property));
-            if (!propertyEntryIter.second) {
-                failIfTrue(propertyEntryIter.first->second == PropertyNode::Constant);
-                failIfTrue(context.getType(property) == PropertyNode::Constant);
-                failIfTrue(context.getType(property) & propertyEntryIter.first->second);
-                propertyEntryIter.first->second |= context.getType(property);
-            }
-        }
-        tail = context.createPropertyList(property, tail);
-    }
-    
-    consumeOrFail(CLOSEBRACE);
-    
-    return context.createObjectLiteral(propertyList);
-}
-
-template <class TreeBuilder> TreeExpression JSParser::parseArrayLiteral(TreeBuilder& context)
-{
-    consumeOrFailWithFlags(OPENBRACKET, TreeBuilder::DontBuildStrings);
-
-    int elisions = 0;
-    while (match(COMMA)) {
-        next(TreeBuilder::DontBuildStrings);
-        elisions++;
-    }
-    if (match(CLOSEBRACKET)) {
-        next(TreeBuilder::DontBuildStrings);
-        return context.createArray(elisions);
-    }
-
-    TreeExpression elem = parseAssignmentExpression(context);
-    failIfFalse(elem);
-    typename TreeBuilder::ElementList elementList = context.createElementList(elisions, elem);
-    typename TreeBuilder::ElementList tail = elementList;
-    elisions = 0;
-    while (match(COMMA)) {
-        next(TreeBuilder::DontBuildStrings);
-        elisions = 0;
-
-        while (match(COMMA)) {
-            next();
-            elisions++;
-        }
-
-        if (match(CLOSEBRACKET)) {
-            next(TreeBuilder::DontBuildStrings);
-            return context.createArray(elisions, elementList);
-        }
-        TreeExpression elem = parseAssignmentExpression(context);
-        failIfFalse(elem);
-        tail = context.createElementList(tail, elisions, elem);
-    }
-
-    consumeOrFail(CLOSEBRACKET);
-
-    return context.createArray(elementList);
-}
-
-template <class TreeBuilder> TreeExpression JSParser::parsePrimaryExpression(TreeBuilder& context)
-{
-    failIfStackOverflow();
-    switch (m_token.m_type) {
-    case OPENBRACE:
-        if (strictMode())
-            return parseStrictObjectLiteral(context);
-        return parseObjectLiteral(context);
-    case OPENBRACKET:
-        return parseArrayLiteral(context);
-    case OPENPAREN: {
-        next();
-        int oldNonLHSCount = m_nonLHSCount;
-        TreeExpression result = parseExpression(context);
-        m_nonLHSCount = oldNonLHSCount;
-        consumeOrFail(CLOSEPAREN);
-
-        return result;
-    }
-    case THISTOKEN: {
-        next();
-        return context.thisExpr();
-    }
-    case IDENT: {
-        int start = tokenStart();
-        const Identifier* ident = m_token.m_data.ident;
-        next();
-        currentScope()->useVariable(ident, m_globalData->propertyNames->eval == *ident);
-        m_lastIdentifier = ident;
-        return context.createResolve(ident, start);
-    }
-    case STRING: {
-        const Identifier* ident = m_token.m_data.ident;
-        next();
-        return context.createString(ident);
-    }
-    case NUMBER: {
-        double d = m_token.m_data.doubleValue;
-        next();
-        return context.createNumberExpr(d);
-    }
-    case NULLTOKEN: {
-        next();
-        return context.createNull();
-    }
-    case TRUETOKEN: {
-        next();
-        return context.createBoolean(true);
-    }
-    case FALSETOKEN: {
-        next();
-        return context.createBoolean(false);
-    }
-    case DIVEQUAL:
-    case DIVIDE: {
-        /* regexp */
-        const Identifier* pattern;
-        const Identifier* flags;
-        if (match(DIVEQUAL))
-            failIfFalse(m_lexer->scanRegExp(pattern, flags, '='));
-        else
-            failIfFalse(m_lexer->scanRegExp(pattern, flags));
-
-        int start = tokenStart();
-        next();
-        TreeExpression re = context.createRegExp(*pattern, *flags, start);
-        if (!re) {
-            const char* yarrErrorMsg = Yarr::checkSyntax(pattern->ustring());
-            ASSERT(!m_errorMessage.isNull());
-            failWithMessage(yarrErrorMsg);
-        }
-        return re;
-    }
-    default:
-        fail();
-    }
-}
-
-template <class TreeBuilder> TreeArguments JSParser::parseArguments(TreeBuilder& context)
-{
-    consumeOrFailWithFlags(OPENPAREN, TreeBuilder::DontBuildStrings);
-    if (match(CLOSEPAREN)) {
-        next(TreeBuilder::DontBuildStrings);
-        return context.createArguments();
-    }
-    TreeExpression firstArg = parseAssignmentExpression(context);
-    failIfFalse(firstArg);
-
-    TreeArgumentsList argList = context.createArgumentsList(firstArg);
-    TreeArgumentsList tail = argList;
-    while (match(COMMA)) {
-        next(TreeBuilder::DontBuildStrings);
-        TreeExpression arg = parseAssignmentExpression(context);
-        failIfFalse(arg);
-        tail = context.createArgumentsList(tail, arg);
-    }
-    consumeOrFail(CLOSEPAREN);
-    return context.createArguments(argList);
-}
-
-template <class TreeBuilder> TreeExpression JSParser::parseMemberExpression(TreeBuilder& context)
-{
-    TreeExpression base = 0;
-    int start = tokenStart();
-    int expressionStart = start;
-    int newCount = 0;
-    while (match(NEW)) {
-        next();
-        newCount++;
-    }
-
-    if (match(FUNCTION)) {
-        const Identifier* name = &m_globalData->propertyNames->nullIdentifier;
-        TreeFormalParameterList parameters = 0;
-        TreeFunctionBody body = 0;
-        int openBracePos = 0;
-        int closeBracePos = 0;
-        int bodyStartLine = 0;
-        next();
-        failIfFalse((parseFunctionInfo<FunctionNoRequirements, false>(context, name, parameters, body, openBracePos, closeBracePos, bodyStartLine)));
-        base = context.createFunctionExpr(name, body, parameters, openBracePos, closeBracePos, bodyStartLine, m_lastLine);
-    } else
-        base = parsePrimaryExpression(context);
-
-    failIfFalse(base);
-    while (true) {
-        switch (m_token.m_type) {
-        case OPENBRACKET: {
-            m_nonTrivialExpressionCount++;
-            int expressionEnd = lastTokenEnd();
-            next();
-            int nonLHSCount = m_nonLHSCount;
-            int initialAssignments = m_assignmentCount;
-            TreeExpression property = parseExpression(context);
-            failIfFalse(property);
-            base = context.createBracketAccess(base, property, initialAssignments != m_assignmentCount, expressionStart, expressionEnd, tokenEnd());
-            consumeOrFail(CLOSEBRACKET);
-            m_nonLHSCount = nonLHSCount;
-            break;
-        }
-        case OPENPAREN: {
-            m_nonTrivialExpressionCount++;
-            if (newCount) {
-                newCount--;
-                if (match(OPENPAREN)) {
-                    int exprEnd = lastTokenEnd();
-                    TreeArguments arguments = parseArguments(context);
-                    failIfFalse(arguments);
-                    base = context.createNewExpr(base, arguments, start, exprEnd, lastTokenEnd());
-                } else
-                    base = context.createNewExpr(base, start, lastTokenEnd());               
-            } else {
-                int nonLHSCount = m_nonLHSCount;
-                int expressionEnd = lastTokenEnd();
-                TreeArguments arguments = parseArguments(context);
-                failIfFalse(arguments);
-                base = context.makeFunctionCallNode(base, arguments, expressionStart, expressionEnd, lastTokenEnd());
-                m_nonLHSCount = nonLHSCount;
-            }
-            break;
-        }
-        case DOT: {
-            m_nonTrivialExpressionCount++;
-            int expressionEnd = lastTokenEnd();
-            nextExpectIdentifier(Lexer::IgnoreReservedWords | TreeBuilder::DontBuildKeywords);
-            matchOrFail(IDENT);
-            base = context.createDotAccess(base, m_token.m_data.ident, expressionStart, expressionEnd, tokenEnd());
-            next();
-            break;
-        }
-        default:
-            goto endMemberExpression;
-        }
-    }
-endMemberExpression:
-    while (newCount--)
-        base = context.createNewExpr(base, start, lastTokenEnd());
-    return base;
-}
-
-template <class TreeBuilder> TreeExpression JSParser::parseUnaryExpression(TreeBuilder& context)
-{
-    typename TreeBuilder::UnaryExprContext unaryExprContext(context);
-    AllowInOverride allowInOverride(this);
-    int tokenStackDepth = 0;
-    bool modifiesExpr = false;
-    bool requiresLExpr = false;
-    while (isUnaryOp(m_token.m_type)) {
-        if (strictMode()) {
-            switch (m_token.m_type) {
-            case PLUSPLUS:
-            case MINUSMINUS:
-            case AUTOPLUSPLUS:
-            case AUTOMINUSMINUS:
-                failIfTrue(requiresLExpr);
-                modifiesExpr = true;
-                requiresLExpr = true;
-                break;
-            case DELETETOKEN:
-                failIfTrue(requiresLExpr);
-                requiresLExpr = true;
-                break;
-            default:
-                failIfTrue(requiresLExpr);
-                break;
-            }
-        }
-        m_nonLHSCount++;
-        context.appendUnaryToken(tokenStackDepth, m_token.m_type, tokenStart());
-        next();
-        m_nonTrivialExpressionCount++;
-    }
-    int subExprStart = tokenStart();
-    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;
-        }
-    }
-    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(expr, OpPlusPlus, subExprStart, lastTokenEnd(), tokenEnd());
-        m_assignmentCount++;
-        failIfTrueIfStrictWithNameAndMessage(isEvalOrArguments, "'", m_lastIdentifier->impl(), "' cannot be modified in strict mode");
-        failIfTrueIfStrict(requiresLExpr);
-        next();
-        break;
-    case MINUSMINUS:
-        m_nonTrivialExpressionCount++;
-        m_nonLHSCount++;
-        expr = context.makePostfixNode(expr, OpMinusMinus, subExprStart, lastTokenEnd(), tokenEnd());
-        m_assignmentCount++;
-        failIfTrueIfStrictWithNameAndMessage(isEvalOrArguments, "'", m_lastIdentifier->impl(), "' cannot be modified in strict mode");
-        failIfTrueIfStrict(requiresLExpr);
-        next();
-        break;
-    default:
-        break;
-    }
-
-    int end = lastTokenEnd();
-
-    if (!TreeBuilder::CreatesAST && (m_syntaxAlreadyValidated || !strictMode()))
-        return expr;
-
-    while (tokenStackDepth) {
-        switch (context.unaryTokenStackLastType(tokenStackDepth)) {
-        case EXCLAMATION:
-            expr = context.createLogicalNot(expr);
-            break;
-        case TILDE:
-            expr = context.makeBitwiseNotNode(expr);
-            break;
-        case MINUS:
-            expr = context.makeNegateNode(expr);
-            break;
-        case PLUS:
-            expr = context.createUnaryPlus(expr);
-            break;
-        case PLUSPLUS:
-        case AUTOPLUSPLUS:
-            expr = context.makePrefixNode(expr, OpPlusPlus, context.unaryTokenStackLastStart(tokenStackDepth), subExprStart + 1, end);
-            m_assignmentCount++;
-            break;
-        case MINUSMINUS:
-        case AUTOMINUSMINUS:
-            expr = context.makePrefixNode(expr, OpMinusMinus, context.unaryTokenStackLastStart(tokenStackDepth), subExprStart + 1, end);
-            m_assignmentCount++;
-            break;
-        case TYPEOF:
-            expr = context.makeTypeOfNode(expr);
-            break;
-        case VOIDTOKEN:
-            expr = context.createVoid(expr);
-            break;
-        case DELETETOKEN:
-            failIfTrueIfStrictWithNameAndMessage(context.isResolve(expr), "Cannot delete unqualified property", m_lastIdentifier->impl(), "in strict mode");
-            expr = context.makeDeleteNode(expr, context.unaryTokenStackLastStart(tokenStackDepth), end, end);
-            break;
-        default:
-            // If we get here something has gone horribly horribly wrong
-            CRASH();
-        }
-        subExprStart = context.unaryTokenStackLastStart(tokenStackDepth);
-        context.unaryTokenStackRemoveLast(tokenStackDepth);
-    }
-    return expr;
-}
-
-}
-
-namespace WTF
-{
-    template <> struct VectorTraits<JSC::JSParser::Scope> : SimpleClassVectorTraits {
-        static const bool canInitializeWithMemset = false; // Not all Scope data members initialize to 0.
-    };
-}
index 21c8e55..c76c2a4 100644 (file)
 using namespace WTF;
 using namespace Unicode;
 
-#include "JSParser.h"
 #include "KeywordLookup.h"
-#include "Lookup.h"
 #include "Lexer.lut.h"
+#include "Parser.h"
 
 namespace JSC {
 
+Keywords::Keywords(JSGlobalData* globalData)
+    : m_globalData(globalData)
+    , m_keywordTable(JSC::mainTable)
+{
+}
 
 enum CharacterType {
     // Types for the main switch
@@ -225,13 +229,11 @@ static const unsigned short typesOfASCIICharacters[128] = {
 Lexer::Lexer(JSGlobalData* globalData)
     : m_isReparsing(false)
     , m_globalData(globalData)
-    , m_keywordTable(JSC::mainTable)
 {
 }
 
 Lexer::~Lexer()
 {
-    m_keywordTable.deleteTable();
 }
     
 UString Lexer::getInvalidCharMessage()
@@ -267,9 +269,9 @@ ALWAYS_INLINE int Lexer::currentOffset() const
     return currentCharacter() - m_codeStart;
 }
 
-void Lexer::setCode(const SourceCode& source, ParserArena& arena)
+void Lexer::setCode(const SourceCode& source, ParserArena* arena)
 {
-    m_arena = &arena.identifierArena();
+    m_arena = &arena->identifierArena();
 
     m_lineNumber = source.firstLine();
     m_delimited = false;
@@ -490,7 +492,7 @@ template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType Lexer::parseIde
         ASSERT(shouldCreateIdentifier);
         // Keywords must not be recognized if there was an \uXXXX in the identifier.
         if (remaining < maxTokenLength) {
-            const HashEntry* entry = m_keywordTable.entry(m_globalData, *ident);
+            const HashEntry* entry = m_globalData->keywords->getKeyword(*ident);
             ASSERT((remaining < maxTokenLength) || !entry);
             if (!entry)
                 return IDENT;
@@ -504,11 +506,6 @@ template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType Lexer::parseIde
     return IDENT;
 }
 
-bool Lexer::isKeyword(const Identifier& ident)
-{
-    return m_keywordTable.entry(m_globalData, ident);
-}
-
 template <bool shouldBuildStrings> ALWAYS_INLINE bool Lexer::parseString(JSTokenData* tokenData, bool strictMode)
 {
     int stringQuoteCharacter = m_current;
index 1ec4773..9c0b639 100644 (file)
@@ -23,9 +23,9 @@
 #ifndef Lexer_h
 #define Lexer_h
 
-#include "JSParser.h"
 #include "Lookup.h"
 #include "ParserArena.h"
+#include "ParserTokens.h"
 #include "SourceCode.h"
 #include <wtf/ASCIICType.h>
 #include <wtf/AlwaysInline.h>
 
 namespace JSC {
 
-    class RegExp;
-
-    class Lexer {
-        WTF_MAKE_NONCOPYABLE(Lexer); WTF_MAKE_FAST_ALLOCATED;
-    public:
-        // Character manipulation functions.
-        static bool isWhiteSpace(int character);
-        static bool isLineTerminator(int character);
-        static unsigned char convertHex(int c1, int c2);
-        static UChar convertUnicode(int c1, int c2, int c3, int c4);
-
-        // Functions to set up parsing.
-        void setCode(const SourceCode&, ParserArena&);
-        void setIsReparsing() { m_isReparsing = true; }
-        bool isReparsing() const { return m_isReparsing; }
-
-        // Functions for the parser itself.
-        enum LexType {
-            IgnoreReservedWords = 1, 
-            DontBuildStrings = 2,
-            DontBuildKeywords = 4
-        };
-        JSTokenType lex(JSTokenData*, JSTokenInfo*, unsigned, bool strictMode);
-        bool nextTokenIsColon();
-        int lineNumber() const { return m_lineNumber; }
-        void setLastLineNumber(int lastLineNumber) { m_lastLineNumber = lastLineNumber; }
-        int lastLineNumber() const { return m_lastLineNumber; }
-        bool prevTerminator() const { return m_terminator; }
-        SourceCode sourceCode(int openBrace, int closeBrace, int firstLine);
-        bool scanRegExp(const Identifier*& pattern, const Identifier*& flags, UChar patternPrefix = 0);
-        bool skipRegExp();
-
-        // Functions for use after parsing.
-        bool sawError() const { return m_error; }
-        UString getErrorMessage() const { return m_lexErrorMessage; }
-        void clear();
-        int currentOffset() { return m_code - m_codeStart; }
-        void setOffset(int offset)
-        {
-            m_error = 0;
-            m_lexErrorMessage = UString();
-            m_code = m_codeStart + offset;
-            m_buffer8.resize(0);
-            m_buffer16.resize(0);
-            // Faster than an if-else sequence
-            m_current = -1;
-            if (LIKELY(m_code < m_codeEnd))
-                m_current = *m_code;
-        }
-        void setLineNumber(int line)
-        {
-            m_lineNumber = line;
-        }
-
-        SourceProvider* sourceProvider() const { return m_source->provider(); }
-        
-        JSTokenType lexExpectIdentifier(JSTokenData*, JSTokenInfo*, unsigned, bool strictMode);
-
-        bool isKeyword(const Identifier&);
-
-    private:
-        friend class JSGlobalData;
-
-        Lexer(JSGlobalData*);
-        ~Lexer();
-
-        void record8(int);
-        void record16(int);
-        void record16(UChar);
-
-        void copyCodeWithoutBOMs();
-
-        ALWAYS_INLINE void shift();
-        ALWAYS_INLINE int peek(int offset);
-        int getUnicodeCharacter();
-        void shiftLineTerminator();
-
-        UString getInvalidCharMessage();
-        ALWAYS_INLINE const UChar* currentCharacter() const;
-        ALWAYS_INLINE int currentOffset() const;
-
-        ALWAYS_INLINE const Identifier* makeIdentifier(const UChar* characters, size_t length);
-
-        ALWAYS_INLINE bool lastTokenWasRestrKeyword() const;
-
-        enum ShiftType { DoBoundsCheck, DoNotBoundsCheck };
-        template <int shiftAmount, ShiftType shouldBoundsCheck> void internalShift();
-        template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType parseKeyword(JSTokenData*);
-        template <bool shouldBuildIdentifiers> ALWAYS_INLINE JSTokenType parseIdentifier(JSTokenData*, unsigned, bool strictMode);
-        template <bool shouldBuildStrings> ALWAYS_INLINE bool parseString(JSTokenData*, bool strictMode);
-        ALWAYS_INLINE void parseHex(double& returnValue);
-        ALWAYS_INLINE bool parseOctal(double& returnValue);
-        ALWAYS_INLINE bool parseDecimal(double& returnValue);
-        ALWAYS_INLINE void parseNumberAfterDecimalPoint();
-        ALWAYS_INLINE bool parseNumberAfterExponentIndicator();
-        ALWAYS_INLINE bool parseMultilineComment();
-
-        static const size_t initialReadBufferCapacity = 32;
-
-        int m_lineNumber;
-        int m_lastLineNumber;
-
-        Vector<char> m_buffer8;
-        Vector<UChar> m_buffer16;
-        bool m_terminator;
-        bool m_delimited; // encountered delimiter like "'" and "}" on last run
-        int m_lastToken;
-
-        const SourceCode* m_source;
-        const UChar* m_code;
-        const UChar* m_codeStart;
-        const UChar* m_codeEnd;
-        bool m_isReparsing;
-        bool m_atLineStart;
-        bool m_error;
-        UString m_lexErrorMessage;
-
-        // current and following unicode characters (int to allow for -1 for end-of-file marker)
-        int m_current;
-
-        IdentifierArena* m_arena;
-
-        JSGlobalData* m_globalData;
-
-        const HashTable m_keywordTable;
-    };
-
-    ALWAYS_INLINE bool Lexer::isWhiteSpace(int ch)
+class Keywords {
+public:
+    bool isKeyword(const Identifier& ident) const
     {
-        return isASCII(ch) ? (ch == ' ' || ch == '\t' || ch == 0xB || ch == 0xC) : (WTF::Unicode::isSeparatorSpace(ch) || ch == 0xFEFF);
+        return m_keywordTable.entry(m_globalData, ident);
     }
-
-    ALWAYS_INLINE bool Lexer::isLineTerminator(int ch)
+    
+    const HashEntry* getKeyword(const Identifier& ident) const
     {
-        return ch == '\r' || ch == '\n' || (ch & ~1) == 0x2028;
+        return m_keywordTable.entry(m_globalData, ident);
     }
-
-    inline unsigned char Lexer::convertHex(int c1, int c2)
+    
+private:
+    friend class JSGlobalData;
+    
+    Keywords(JSGlobalData*);
+    
+    ~Keywords()
     {
-        return (toASCIIHexValue(c1) << 4) | toASCIIHexValue(c2);
+        m_keywordTable.deleteTable();
     }
-
-    inline UChar Lexer::convertUnicode(int c1, int c2, int c3, int c4)
+    
+    JSGlobalData* m_globalData;
+    const HashTable m_keywordTable;
+};
+
+class RegExp;
+
+class Lexer {
+    WTF_MAKE_NONCOPYABLE(Lexer);
+    WTF_MAKE_FAST_ALLOCATED;
+
+public:
+    Lexer(JSGlobalData*);
+    ~Lexer();
+
+    // Character manipulation functions.
+    static bool isWhiteSpace(int character);
+    static bool isLineTerminator(int character);
+    static unsigned char convertHex(int c1, int c2);
+    static UChar convertUnicode(int c1, int c2, int c3, int c4);
+
+    // Functions to set up parsing.
+    void setCode(const SourceCode&, ParserArena*);
+    void setIsReparsing() { m_isReparsing = true; }
+    bool isReparsing() const { return m_isReparsing; }
+
+    // Functions for the parser itself.
+    enum LexType {
+        IgnoreReservedWords = 1, 
+        DontBuildStrings = 2,
+        DontBuildKeywords = 4
+    };
+    JSTokenType lex(JSTokenData*, JSTokenInfo*, unsigned, bool strictMode);
+    bool nextTokenIsColon();
+    int lineNumber() const { return m_lineNumber; }
+    void setLastLineNumber(int lastLineNumber) { m_lastLineNumber = lastLineNumber; }
+    int lastLineNumber() const { return m_lastLineNumber; }
+    bool prevTerminator() const { return m_terminator; }
+    SourceCode sourceCode(int openBrace, int closeBrace, int firstLine);
+    bool scanRegExp(const Identifier*& pattern, const Identifier*& flags, UChar patternPrefix = 0);
+    bool skipRegExp();
+
+    // Functions for use after parsing.
+    bool sawError() const { return m_error; }
+    UString getErrorMessage() const { return m_lexErrorMessage; }
+    void clear();
+    int currentOffset() { return m_code - m_codeStart; }
+    void setOffset(int offset)
     {
-        return (convertHex(c1, c2) << 8) | convertHex(c3, c4);
+        m_error = 0;
+        m_lexErrorMessage = UString();
+        m_code = m_codeStart + offset;
+        m_buffer8.resize(0);
+        m_buffer16.resize(0);
+        // Faster than an if-else sequence
+        m_current = -1;
+        if (LIKELY(m_code < m_codeEnd))
+            m_current = *m_code;
     }
-    
-    ALWAYS_INLINE const Identifier* Lexer::makeIdentifier(const UChar* characters, size_t length)
+    void setLineNumber(int line)
     {
-        return &m_arena->makeIdentifier(m_globalData, characters, length);
+        m_lineNumber = line;
     }
 
-    ALWAYS_INLINE JSTokenType Lexer::lexExpectIdentifier(JSTokenData* tokenData, JSTokenInfo* tokenInfo, unsigned lexType, bool strictMode)
-    {
-        ASSERT((lexType & IgnoreReservedWords));
-        const UChar* start = m_code;
-        const UChar* ptr = start;
-        const UChar* end = m_codeEnd;
-        if (ptr >= end) {
-            ASSERT(ptr == end);
-            goto slowCase;
-        }
-        if (!WTF::isASCIIAlpha(*ptr))
-            goto slowCase;
+    SourceProvider* sourceProvider() const { return m_source->provider(); }
+    
+    JSTokenType lexExpectIdentifier(JSTokenData*, JSTokenInfo*, unsigned, bool strictMode);
+
+private:
+    friend class JSGlobalData;
+
+    void record8(int);
+    void record16(int);
+    void record16(UChar);
+
+    void copyCodeWithoutBOMs();
+
+    ALWAYS_INLINE void shift();
+    ALWAYS_INLINE int peek(int offset);
+    int getUnicodeCharacter();
+    void shiftLineTerminator();
+
+    UString getInvalidCharMessage();
+    ALWAYS_INLINE const UChar* currentCharacter() const;
+    ALWAYS_INLINE int currentOffset() const;
+
+    ALWAYS_INLINE const Identifier* makeIdentifier(const UChar* characters, size_t length);
+
+    ALWAYS_INLINE bool lastTokenWasRestrKeyword() const;
+
+    enum ShiftType { DoBoundsCheck, DoNotBoundsCheck };
+    template <int shiftAmount, ShiftType shouldBoundsCheck> void internalShift();
+    template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType parseKeyword(JSTokenData*);
+    template <bool shouldBuildIdentifiers> ALWAYS_INLINE JSTokenType parseIdentifier(JSTokenData*, unsigned, bool strictMode);
+    template <bool shouldBuildStrings> ALWAYS_INLINE bool parseString(JSTokenData*, bool strictMode);
+    ALWAYS_INLINE void parseHex(double& returnValue);
+    ALWAYS_INLINE bool parseOctal(double& returnValue);
+    ALWAYS_INLINE bool parseDecimal(double& returnValue);
+    ALWAYS_INLINE void parseNumberAfterDecimalPoint();
+    ALWAYS_INLINE bool parseNumberAfterExponentIndicator();
+    ALWAYS_INLINE bool parseMultilineComment();
+
+    static const size_t initialReadBufferCapacity = 32;
+
+    int m_lineNumber;
+    int m_lastLineNumber;
+
+    Vector<char> m_buffer8;
+    Vector<UChar> m_buffer16;
+    bool m_terminator;
+    bool m_delimited; // encountered delimiter like "'" and "}" on last run
+    int m_lastToken;
+
+    const SourceCode* m_source;
+    const UChar* m_code;
+    const UChar* m_codeStart;
+    const UChar* m_codeEnd;
+    bool m_isReparsing;
+    bool m_atLineStart;
+    bool m_error;
+    UString m_lexErrorMessage;
+
+    // current and following unicode characters (int to allow for -1 for end-of-file marker)
+    int m_current;
+
+    IdentifierArena* m_arena;
+
+    JSGlobalData* m_globalData;
+};
+
+ALWAYS_INLINE bool Lexer::isWhiteSpace(int ch)
+{
+    return isASCII(ch) ? (ch == ' ' || ch == '\t' || ch == 0xB || ch == 0xC) : (WTF::Unicode::isSeparatorSpace(ch) || ch == 0xFEFF);
+}
+
+ALWAYS_INLINE bool Lexer::isLineTerminator(int ch)
+{
+    return ch == '\r' || ch == '\n' || (ch & ~1) == 0x2028;
+}
+
+inline unsigned char Lexer::convertHex(int c1, int c2)
+{
+    return (toASCIIHexValue(c1) << 4) | toASCIIHexValue(c2);
+}
+
+inline UChar Lexer::convertUnicode(int c1, int c2, int c3, int c4)
+{
+    return (convertHex(c1, c2) << 8) | convertHex(c3, c4);
+}
+
+ALWAYS_INLINE const Identifier* Lexer::makeIdentifier(const UChar* characters, size_t length)
+{
+    return &m_arena->makeIdentifier(m_globalData, characters, length);
+}
+
+ALWAYS_INLINE JSTokenType Lexer::lexExpectIdentifier(JSTokenData* tokenData, JSTokenInfo* tokenInfo, unsigned lexType, bool strictMode)
+{
+    ASSERT((lexType & IgnoreReservedWords));
+    const UChar* start = m_code;
+    const UChar* ptr = start;
+    const UChar* end = m_codeEnd;
+    if (ptr >= end) {
+        ASSERT(ptr == end);
+        goto slowCase;
+    }
+    if (!WTF::isASCIIAlpha(*ptr))
+        goto slowCase;
+    ++ptr;
+    while (ptr < end) {
+        if (!WTF::isASCIIAlphanumeric(*ptr))
+            break;
         ++ptr;
-        while (ptr < end) {
-            if (!WTF::isASCIIAlphanumeric(*ptr))
-                break;
-            ++ptr;
-        }
-
-        // Here's the shift
-        if (ptr < end) {
-            if ((!WTF::isASCII(*ptr)) || (*ptr == '\\') || (*ptr == '_') || (*ptr == '$'))
-                goto slowCase;
-            m_current = *ptr;
-        } else
-            m_current = -1;
-
-        m_code = ptr;
-
-        // Create the identifier if needed
-        if (lexType & DontBuildKeywords)
-            tokenData->ident = 0;
-        else
-            tokenData->ident = makeIdentifier(start, ptr - start);
-        tokenInfo->line = m_lineNumber;
-        tokenInfo->startOffset = start - m_codeStart;
-        tokenInfo->endOffset = currentOffset();
-        m_lastToken = IDENT;
-        return IDENT;
-        
-    slowCase:
-        return lex(tokenData, tokenInfo, lexType, strictMode);
     }
 
+    // Here's the shift
+    if (ptr < end) {
+        if ((!WTF::isASCII(*ptr)) || (*ptr == '\\') || (*ptr == '_') || (*ptr == '$'))
+            goto slowCase;
+        m_current = *ptr;
+    } else
+        m_current = -1;
+
+    m_code = ptr;
+
+    // Create the identifier if needed
+    if (lexType & DontBuildKeywords)
+        tokenData->ident = 0;
+    else
+        tokenData->ident = makeIdentifier(start, ptr - start);
+    tokenInfo->line = m_lineNumber;
+    tokenInfo->startOffset = start - m_codeStart;
+    tokenInfo->endOffset = currentOffset();
+    m_lastToken = IDENT;
+    return IDENT;
+    
+slowCase:
+    return lex(tokenData, tokenInfo, lexType, strictMode);
+}
+
 } // namespace JSC
 
 #endif // Lexer_h
index 5f99b3d..6c06949 100644 (file)
@@ -29,86 +29,86 @@ namespace JSC {
 
     inline void* ParserArenaFreeable::operator new(size_t size, JSGlobalData* globalData)
     {
-        return globalData->parser->arena().allocateFreeable(size);
+        return globalData->parserArena->allocateFreeable(size);
     }
 
     inline void* ParserArenaDeletable::operator new(size_t size, JSGlobalData* globalData)
     {
-        return globalData->parser->arena().allocateDeletable(size);
+        return globalData->parserArena->allocateDeletable(size);
     }
 
     inline ParserArenaRefCounted::ParserArenaRefCounted(JSGlobalData* globalData)
     {
-        globalData->parser->arena().derefWithArena(adoptRef(this));
+        globalData->parserArena->derefWithArena(adoptRef(this));
     }
 
-    inline Node::Node(JSGlobalData* globalData)
-        : m_line(globalData->lexer->lastLineNumber())
+    inline Node::Node(int lineNumber)
+        : m_lineNumber(lineNumber)
     {
     }
 
-    inline ExpressionNode::ExpressionNode(JSGlobalData* globalData, ResultType resultType)
-        : Node(globalData)
+    inline ExpressionNode::ExpressionNode(int lineNumber, ResultType resultType)
+        : Node(lineNumber)
         , m_resultType(resultType)
     {
     }
 
-    inline StatementNode::StatementNode(JSGlobalData* globalData)
-        : Node(globalData)
+    inline StatementNode::StatementNode(int lineNumber)
+        : Node(lineNumber)
         , m_lastLine(-1)
     {
     }
 
-    inline NullNode::NullNode(JSGlobalData* globalData)
-        : ExpressionNode(globalData, ResultType::nullType())
+    inline NullNode::NullNode(int lineNumber)
+        : ExpressionNode(lineNumber, ResultType::nullType())
     {
     }
 
-    inline BooleanNode::BooleanNode(JSGlobalData* globalData, bool value)
-        : ExpressionNode(globalData, ResultType::booleanType())
+    inline BooleanNode::BooleanNode(int lineNumber, bool value)
+        : ExpressionNode(lineNumber, ResultType::booleanType())
         , m_value(value)
     {
     }
 
-    inline NumberNode::NumberNode(JSGlobalData* globalData, double value)
-        : ExpressionNode(globalData, ResultType::numberType())
+    inline NumberNode::NumberNode(int lineNumber, double value)
+        : ExpressionNode(lineNumber, ResultType::numberType())
         , m_value(value)
     {
     }
 
-    inline StringNode::StringNode(JSGlobalData* globalData, const Identifier& value)
-        : ExpressionNode(globalData, ResultType::stringType())
+    inline StringNode::StringNode(int lineNumber, const Identifier& value)
+        : ExpressionNode(lineNumber, ResultType::stringType())
         , m_value(value)
     {
     }
 
-    inline RegExpNode::RegExpNode(JSGlobalData* globalData, const Identifier& pattern, const Identifier& flags)
-        : ExpressionNode(globalData)
+    inline RegExpNode::RegExpNode(int lineNumber, const Identifier& pattern, const Identifier& flags)
+        : ExpressionNode(lineNumber)
         , m_pattern(pattern)
         , m_flags(flags)
     {
     }
 
-    inline ThisNode::ThisNode(JSGlobalData* globalData)
-        : ExpressionNode(globalData)
+    inline ThisNode::ThisNode(int lineNumber)
+        : ExpressionNode(lineNumber)
     {
     }
 
-    inline ResolveNode::ResolveNode(JSGlobalData* globalData, const Identifier& ident, int startOffset)
-        : ExpressionNode(globalData)
+    inline ResolveNode::ResolveNode(int lineNumber, const Identifier& ident, int startOffset)
+        : ExpressionNode(lineNumber)
         , m_ident(ident)
         , m_startOffset(startOffset)
     {
     }
 
-    inline ElementNode::ElementNode(JSGlobalData*, int elision, ExpressionNode* node)
+    inline ElementNode::ElementNode(int elision, ExpressionNode* node)
         : m_next(0)
         , m_elision(elision)
         , m_node(node)
     {
     }
 
-    inline ElementNode::ElementNode(JSGlobalData*, ElementNode* l, int elision, ExpressionNode* node)
+    inline ElementNode::ElementNode(ElementNode* l, int elision, ExpressionNode* node)
         : m_next(0)
         , m_elision(elision)
         , m_node(node)
@@ -116,24 +116,24 @@ namespace JSC {
         l->m_next = this;
     }
 
-    inline ArrayNode::ArrayNode(JSGlobalData* globalData, int elision)
-        : ExpressionNode(globalData)
+    inline ArrayNode::ArrayNode(int lineNumber, int elision)
+        : ExpressionNode(lineNumber)
         , m_element(0)
         , m_elision(elision)
         , m_optional(true)
     {
     }
 
-    inline ArrayNode::ArrayNode(JSGlobalData* globalData, ElementNode* element)
-        : ExpressionNode(globalData)
+    inline ArrayNode::ArrayNode(int lineNumber, ElementNode* element)
+        : ExpressionNode(lineNumber)
         , m_element(element)
         , m_elision(0)
         , m_optional(false)
     {
     }
 
-    inline ArrayNode::ArrayNode(JSGlobalData* globalData, int elision, ElementNode* element)
-        : ExpressionNode(globalData)
+    inline ArrayNode::ArrayNode(int lineNumber, int elision, ElementNode* element)
+        : ExpressionNode(lineNumber)
         , m_element(element)
         , m_elision(elision)
         , m_optional(true)
@@ -148,118 +148,118 @@ namespace JSC {
     }
 
     inline PropertyNode::PropertyNode(JSGlobalData* globalData, double name, ExpressionNode* assign, Type type)
-        : m_name(globalData->parser->arena().identifierArena().makeNumericIdentifier(globalData, name))
+        : m_name(globalData->parserArena->identifierArena().makeNumericIdentifier(globalData, name))
         , m_assign(assign)
         , m_type(type)
     {
     }
 
-    inline PropertyListNode::PropertyListNode(JSGlobalData* globalData, PropertyNode* node)
-        : Node(globalData)
+    inline PropertyListNode::PropertyListNode(int lineNumber, PropertyNode* node)
+        : Node(lineNumber)
         , m_node(node)
         , m_next(0)
     {
     }
 
-    inline PropertyListNode::PropertyListNode(JSGlobalData* globalData, PropertyNode* node, PropertyListNode* list)
-        : Node(globalData)
+    inline PropertyListNode::PropertyListNode(int lineNumber, PropertyNode* node, PropertyListNode* list)
+        : Node(lineNumber)
         , m_node(node)
         , m_next(0)
     {
         list->m_next = this;
     }
 
-    inline ObjectLiteralNode::ObjectLiteralNode(JSGlobalData* globalData)
-        : ExpressionNode(globalData)
+    inline ObjectLiteralNode::ObjectLiteralNode(int lineNumber)
+        : ExpressionNode(lineNumber)
         , m_list(0)
     {
     }
 
-    inline ObjectLiteralNode::ObjectLiteralNode(JSGlobalData* globalData, PropertyListNode* list)
-        : ExpressionNode(globalData)
+    inline ObjectLiteralNode::ObjectLiteralNode(int lineNumber, PropertyListNode* list)
+        : ExpressionNode(lineNumber)
         , m_list(list)
     {
     }
 
-    inline BracketAccessorNode::BracketAccessorNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments)
-        : ExpressionNode(globalData)
+    inline BracketAccessorNode::BracketAccessorNode(int lineNumber, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments)
+        : ExpressionNode(lineNumber)
         , m_base(base)
         , m_subscript(subscript)
         , m_subscriptHasAssignments(subscriptHasAssignments)
     {
     }
 
-    inline DotAccessorNode::DotAccessorNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident)
-        : ExpressionNode(globalData)
+    inline DotAccessorNode::DotAccessorNode(int lineNumber, ExpressionNode* base, const Identifier& ident)
+        : ExpressionNode(lineNumber)
         , m_base(base)
         , m_ident(ident)
     {
     }
 
-    inline ArgumentListNode::ArgumentListNode(JSGlobalData* globalData, ExpressionNode* expr)
-        : Node(globalData)
+    inline ArgumentListNode::ArgumentListNode(int lineNumber, ExpressionNode* expr)
+        : Node(lineNumber)
         , m_next(0)
         , m_expr(expr)
     {
     }
 
-    inline ArgumentListNode::ArgumentListNode(JSGlobalData* globalData, ArgumentListNode* listNode, ExpressionNode* expr)
-        : Node(globalData)
+    inline ArgumentListNode::ArgumentListNode(int lineNumber, ArgumentListNode* listNode, ExpressionNode* expr)
+        : Node(lineNumber)
         , m_next(0)
         , m_expr(expr)
     {
         listNode->m_next = this;
     }
 
-    inline ArgumentsNode::ArgumentsNode(JSGlobalData*)
+    inline ArgumentsNode::ArgumentsNode()
         : m_listNode(0)
     {
     }
 
-    inline ArgumentsNode::ArgumentsNode(JSGlobalData*, ArgumentListNode* listNode)
+    inline ArgumentsNode::ArgumentsNode(ArgumentListNode* listNode)
         : m_listNode(listNode)
     {
     }
 
-    inline NewExprNode::NewExprNode(JSGlobalData* globalData, ExpressionNode* expr)
-        : ExpressionNode(globalData)
+    inline NewExprNode::NewExprNode(int lineNumber, ExpressionNode* expr)
+        : ExpressionNode(lineNumber)
         , m_expr(expr)
         , m_args(0)
     {
     }
 
-    inline NewExprNode::NewExprNode(JSGlobalData* globalData, ExpressionNode* expr, ArgumentsNode* args)
-        : ExpressionNode(globalData)
+    inline NewExprNode::NewExprNode(int lineNumber, ExpressionNode* expr, ArgumentsNode* args)
+        : ExpressionNode(lineNumber)
         , m_expr(expr)
         , m_args(args)
     {
     }
 
-    inline EvalFunctionCallNode::EvalFunctionCallNode(JSGlobalData* globalData, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline EvalFunctionCallNode::EvalFunctionCallNode(int lineNumber, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableExpressionData(divot, startOffset, endOffset)
         , m_args(args)
     {
     }
 
-    inline FunctionCallValueNode::FunctionCallValueNode(JSGlobalData* globalData, ExpressionNode* expr, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline FunctionCallValueNode::FunctionCallValueNode(int lineNumber, ExpressionNode* expr, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableExpressionData(divot, startOffset, endOffset)
         , m_expr(expr)
         , m_args(args)
     {
     }
 
-    inline FunctionCallResolveNode::FunctionCallResolveNode(JSGlobalData* globalData, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline FunctionCallResolveNode::FunctionCallResolveNode(int lineNumber, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableExpressionData(divot, startOffset, endOffset)
         , m_ident(ident)
         , m_args(args)
     {
     }
 
-    inline FunctionCallBracketNode::FunctionCallBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline FunctionCallBracketNode::FunctionCallBracketNode(int lineNumber, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableSubExpressionData(divot, startOffset, endOffset)
         , m_base(base)
         , m_subscript(subscript)
@@ -267,8 +267,8 @@ namespace JSC {
     {
     }
 
-    inline FunctionCallDotNode::FunctionCallDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline FunctionCallDotNode::FunctionCallDotNode(int lineNumber, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableSubExpressionData(divot, startOffset, endOffset)
         , m_base(base)
         , m_ident(ident)
@@ -276,31 +276,31 @@ namespace JSC {
     {
     }
 
-    inline CallFunctionCallDotNode::CallFunctionCallDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : FunctionCallDotNode(globalData, base, ident, args, divot, startOffset, endOffset)
+    inline CallFunctionCallDotNode::CallFunctionCallDotNode(int lineNumber, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : FunctionCallDotNode(lineNumber, base, ident, args, divot, startOffset, endOffset)
     {
     }
 
-    inline ApplyFunctionCallDotNode::ApplyFunctionCallDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : FunctionCallDotNode(globalData, base, ident, args, divot, startOffset, endOffset)
+    inline ApplyFunctionCallDotNode::ApplyFunctionCallDotNode(int lineNumber, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : FunctionCallDotNode(lineNumber, base, ident, args, divot, startOffset, endOffset)
     {
     }
 
-    inline PrePostResolveNode::PrePostResolveNode(JSGlobalData* globalData, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData, ResultType::numberType()) // could be reusable for pre?
+    inline PrePostResolveNode::PrePostResolveNode(int lineNumber, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber, ResultType::numberType()) // could be reusable for pre?
         , ThrowableExpressionData(divot, startOffset, endOffset)
         , m_ident(ident)
     {
     }
 
-    inline PostfixResolveNode::PostfixResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : PrePostResolveNode(globalData, ident, divot, startOffset, endOffset)
+    inline PostfixResolveNode::PostfixResolveNode(int lineNumber, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : PrePostResolveNode(lineNumber, ident, divot, startOffset, endOffset)
         , m_operator(oper)
     {
     }
 
-    inline PostfixBracketNode::PostfixBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline PostfixBracketNode::PostfixBracketNode(int lineNumber, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableSubExpressionData(divot, startOffset, endOffset)
         , m_base(base)
         , m_subscript(subscript)
@@ -308,8 +308,8 @@ namespace JSC {
     {
     }
 
-    inline PostfixDotNode::PostfixDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline PostfixDotNode::PostfixDotNode(int lineNumber, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableSubExpressionData(divot, startOffset, endOffset)
         , m_base(base)
         , m_ident(ident)
@@ -317,69 +317,69 @@ namespace JSC {
     {
     }
 
-    inline PostfixErrorNode::PostfixErrorNode(JSGlobalData* globalData, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline PostfixErrorNode::PostfixErrorNode(int lineNumber, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableSubExpressionData(divot, startOffset, endOffset)
         , m_expr(expr)
         , m_operator(oper)
     {
     }
 
-    inline DeleteResolveNode::DeleteResolveNode(JSGlobalData* globalData, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline DeleteResolveNode::DeleteResolveNode(int lineNumber, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableExpressionData(divot, startOffset, endOffset)
         , m_ident(ident)
     {
     }
 
-    inline DeleteBracketNode::DeleteBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline DeleteBracketNode::DeleteBracketNode(int lineNumber, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableExpressionData(divot, startOffset, endOffset)
         , m_base(base)
         , m_subscript(subscript)
     {
     }
 
-    inline DeleteDotNode::DeleteDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline DeleteDotNode::DeleteDotNode(int lineNumber, ExpressionNode* base, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableExpressionData(divot, startOffset, endOffset)
         , m_base(base)
         , m_ident(ident)
     {
     }
 
-    inline DeleteValueNode::DeleteValueNode(JSGlobalData* globalData, ExpressionNode* expr)
-        : ExpressionNode(globalData)
+    inline DeleteValueNode::DeleteValueNode(int lineNumber, ExpressionNode* expr)
+        : ExpressionNode(lineNumber)
         , m_expr(expr)
     {
     }
 
-    inline VoidNode::VoidNode(JSGlobalData* globalData, ExpressionNode* expr)
-        : ExpressionNode(globalData)
+    inline VoidNode::VoidNode(int lineNumber, ExpressionNode* expr)
+        : ExpressionNode(lineNumber)
         , m_expr(expr)
     {
     }
 
-    inline TypeOfResolveNode::TypeOfResolveNode(JSGlobalData* globalData, const Identifier& ident)
-        : ExpressionNode(globalData, ResultType::stringType())
+    inline TypeOfResolveNode::TypeOfResolveNode(int lineNumber, const Identifier& ident)
+        : ExpressionNode(lineNumber, ResultType::stringType())
         , m_ident(ident)
     {
     }
 
-    inline TypeOfValueNode::TypeOfValueNode(JSGlobalData* globalData, ExpressionNode* expr)
-        : ExpressionNode(globalData, ResultType::stringType())
+    inline TypeOfValueNode::TypeOfValueNode(int lineNumber, ExpressionNode* expr)
+        : ExpressionNode(lineNumber, ResultType::stringType())
         , m_expr(expr)
     {
     }
 
-    inline PrefixResolveNode::PrefixResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : PrePostResolveNode(globalData, ident, divot, startOffset, endOffset)
+    inline PrefixResolveNode::PrefixResolveNode(int lineNumber, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : PrePostResolveNode(lineNumber, ident, divot, startOffset, endOffset)
         , m_operator(oper)
     {
     }
 
-    inline PrefixBracketNode::PrefixBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline PrefixBracketNode::PrefixBracketNode(int lineNumber, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowablePrefixedSubExpressionData(divot, startOffset, endOffset)
         , m_base(base)
         , m_subscript(subscript)
@@ -387,8 +387,8 @@ namespace JSC {
     {
     }
 
-    inline PrefixDotNode::PrefixDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline PrefixDotNode::PrefixDotNode(int lineNumber, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowablePrefixedSubExpressionData(divot, startOffset, endOffset)
         , m_base(base)
         , m_ident(ident)
@@ -396,43 +396,43 @@ namespace JSC {
     {
     }
 
-    inline PrefixErrorNode::PrefixErrorNode(JSGlobalData* globalData, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline PrefixErrorNode::PrefixErrorNode(int lineNumber, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableExpressionData(divot, startOffset, endOffset)
         , m_expr(expr)
         , m_operator(oper)
     {
     }
 
-    inline UnaryOpNode::UnaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr, OpcodeID opcodeID)
-        : ExpressionNode(globalData, type)
+    inline UnaryOpNode::UnaryOpNode(int lineNumber, ResultType type, ExpressionNode* expr, OpcodeID opcodeID)
+        : ExpressionNode(lineNumber, type)
         , m_expr(expr)
         , m_opcodeID(opcodeID)
     {
     }
 
-    inline UnaryPlusNode::UnaryPlusNode(JSGlobalData* globalData, ExpressionNode* expr)
-        : UnaryOpNode(globalData, ResultType::numberType(), expr, op_to_jsnumber)
+    inline UnaryPlusNode::UnaryPlusNode(int lineNumber, ExpressionNode* expr)
+        : UnaryOpNode(lineNumber, ResultType::numberType(), expr, op_to_jsnumber)
     {
     }
 
-    inline NegateNode::NegateNode(JSGlobalData* globalData, ExpressionNode* expr)
-        : UnaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr, op_negate)
+    inline NegateNode::NegateNode(int lineNumber, ExpressionNode* expr)
+        : UnaryOpNode(lineNumber, ResultType::numberTypeCanReuse(), expr, op_negate)
     {
     }
 
-    inline BitwiseNotNode::BitwiseNotNode(JSGlobalData* globalData, ExpressionNode* expr)
-        : UnaryOpNode(globalData, ResultType::forBitOp(), expr, op_bitnot)
+    inline BitwiseNotNode::BitwiseNotNode(int lineNumber, ExpressionNode* expr)
+        : UnaryOpNode(lineNumber, ResultType::forBitOp(), expr, op_bitnot)
     {
     }
 
-    inline LogicalNotNode::LogicalNotNode(JSGlobalData* globalData, ExpressionNode* expr)
-        : UnaryOpNode(globalData, ResultType::booleanType(), expr, op_not)
+    inline LogicalNotNode::LogicalNotNode(int lineNumber, ExpressionNode* expr)
+        : UnaryOpNode(lineNumber, ResultType::booleanType(), expr, op_not)
     {
     }
 
-    inline BinaryOpNode::BinaryOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
-        : ExpressionNode(globalData)
+    inline BinaryOpNode::BinaryOpNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
+        : ExpressionNode(lineNumber)
         , m_expr1(expr1)
         , m_expr2(expr2)
         , m_opcodeID(opcodeID)
@@ -440,8 +440,8 @@ namespace JSC {
     {
     }
 
-    inline BinaryOpNode::BinaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
-        : ExpressionNode(globalData, type)
+    inline BinaryOpNode::BinaryOpNode(int lineNumber, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
+        : ExpressionNode(lineNumber, type)
         , m_expr1(expr1)
         , m_expr2(expr2)
         , m_opcodeID(opcodeID)
@@ -449,140 +449,140 @@ namespace JSC {
     {
     }
 
-    inline MultNode::MultNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, op_mul, rightHasAssignments)
+    inline MultNode::MultNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::numberTypeCanReuse(), expr1, expr2, op_mul, rightHasAssignments)
     {
     }
 
-    inline DivNode::DivNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, op_div, rightHasAssignments)
+    inline DivNode::DivNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::numberTypeCanReuse(), expr1, expr2, op_div, rightHasAssignments)
     {
     }
 
 
-    inline ModNode::ModNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, op_mod, rightHasAssignments)
+    inline ModNode::ModNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::numberTypeCanReuse(), expr1, expr2, op_mod, rightHasAssignments)
     {
     }
 
-    inline AddNode::AddNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::forAdd(expr1->resultDescriptor(), expr2->resultDescriptor()), expr1, expr2, op_add, rightHasAssignments)
+    inline AddNode::AddNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::forAdd(expr1->resultDescriptor(), expr2->resultDescriptor()), expr1, expr2, op_add, rightHasAssignments)
     {
     }
 
-    inline SubNode::SubNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, op_sub, rightHasAssignments)
+    inline SubNode::SubNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::numberTypeCanReuse(), expr1, expr2, op_sub, rightHasAssignments)
     {
     }
 
-    inline LeftShiftNode::LeftShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, op_lshift, rightHasAssignments)
+    inline LeftShiftNode::LeftShiftNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::forBitOp(), expr1, expr2, op_lshift, rightHasAssignments)
     {
     }
 
-    inline RightShiftNode::RightShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, op_rshift, rightHasAssignments)
+    inline RightShiftNode::RightShiftNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::forBitOp(), expr1, expr2, op_rshift, rightHasAssignments)
     {
     }
 
-    inline UnsignedRightShiftNode::UnsignedRightShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, op_urshift, rightHasAssignments)
+    inline UnsignedRightShiftNode::UnsignedRightShiftNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::numberTypeCanReuse(), expr1, expr2, op_urshift, rightHasAssignments)
     {
     }
 
-    inline LessNode::LessNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_less, rightHasAssignments)
+    inline LessNode::LessNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::booleanType(), expr1, expr2, op_less, rightHasAssignments)
     {
     }
 
-    inline GreaterNode::GreaterNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_greater, rightHasAssignments)
+    inline GreaterNode::GreaterNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::booleanType(), expr1, expr2, op_greater, rightHasAssignments)
     {
     }
 
-    inline LessEqNode::LessEqNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_lesseq, rightHasAssignments)
+    inline LessEqNode::LessEqNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::booleanType(), expr1, expr2, op_lesseq, rightHasAssignments)
     {
     }
 
-    inline GreaterEqNode::GreaterEqNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_greatereq, rightHasAssignments)
+    inline GreaterEqNode::GreaterEqNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::booleanType(), expr1, expr2, op_greatereq, rightHasAssignments)
     {
     }
 
-    inline ThrowableBinaryOpNode::ThrowableBinaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
-        : BinaryOpNode(globalData, type, expr1, expr2, opcodeID, rightHasAssignments)
+    inline ThrowableBinaryOpNode::ThrowableBinaryOpNode(int lineNumber, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, type, expr1, expr2, opcodeID, rightHasAssignments)
     {
     }
 
-    inline ThrowableBinaryOpNode::ThrowableBinaryOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
-        : BinaryOpNode(globalData, expr1, expr2, opcodeID, rightHasAssignments)
+    inline ThrowableBinaryOpNode::ThrowableBinaryOpNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, expr1, expr2, opcodeID, rightHasAssignments)
     {
     }
 
-    inline InstanceOfNode::InstanceOfNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : ThrowableBinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_instanceof, rightHasAssignments)
+    inline InstanceOfNode::InstanceOfNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : ThrowableBinaryOpNode(lineNumber, ResultType::booleanType(), expr1, expr2, op_instanceof, rightHasAssignments)
     {
     }
 
-    inline InNode::InNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : ThrowableBinaryOpNode(globalData, expr1, expr2, op_in, rightHasAssignments)
+    inline InNode::InNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : ThrowableBinaryOpNode(lineNumber, expr1, expr2, op_in, rightHasAssignments)
     {
     }
 
-    inline EqualNode::EqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_eq, rightHasAssignments)
+    inline EqualNode::EqualNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::booleanType(), expr1, expr2, op_eq, rightHasAssignments)
     {
     }
 
-    inline NotEqualNode::NotEqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_neq, rightHasAssignments)
+    inline NotEqualNode::NotEqualNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::booleanType(), expr1, expr2, op_neq, rightHasAssignments)
     {
     }
 
-    inline StrictEqualNode::StrictEqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_stricteq, rightHasAssignments)
+    inline StrictEqualNode::StrictEqualNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::booleanType(), expr1, expr2, op_stricteq, rightHasAssignments)
     {
     }
 
-    inline NotStrictEqualNode::NotStrictEqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_nstricteq, rightHasAssignments)
+    inline NotStrictEqualNode::NotStrictEqualNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::booleanType(), expr1, expr2, op_nstricteq, rightHasAssignments)
     {
     }
 
-    inline BitAndNode::BitAndNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, op_bitand, rightHasAssignments)
+    inline BitAndNode::BitAndNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::forBitOp(), expr1, expr2, op_bitand, rightHasAssignments)
     {
     }
 
-    inline BitOrNode::BitOrNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, op_bitor, rightHasAssignments)
+    inline BitOrNode::BitOrNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::forBitOp(), expr1, expr2, op_bitor, rightHasAssignments)
     {
     }
 
-    inline BitXOrNode::BitXOrNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
-        : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, op_bitxor, rightHasAssignments)
+    inline BitXOrNode::BitXOrNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
+        : BinaryOpNode(lineNumber, ResultType::forBitOp(), expr1, expr2, op_bitxor, rightHasAssignments)
     {
     }
 
-    inline LogicalOpNode::LogicalOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator oper)
-        : ExpressionNode(globalData, ResultType::booleanType())
+    inline LogicalOpNode::LogicalOpNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator oper)
+        : ExpressionNode(lineNumber, ResultType::booleanType())
         , m_expr1(expr1)
         , m_expr2(expr2)
         , m_operator(oper)
     {
     }
 
-    inline ConditionalNode::ConditionalNode(JSGlobalData* globalData, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2)
-        : ExpressionNode(globalData)
+    inline ConditionalNode::ConditionalNode(int lineNumber, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2)
+        : ExpressionNode(lineNumber)
         , m_logical(logical)
         , m_expr1(expr1)
         , m_expr2(expr2)
     {
     }
 
-    inline ReadModifyResolveNode::ReadModifyResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, ExpressionNode*  right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline ReadModifyResolveNode::ReadModifyResolveNode(int lineNumber, const Identifier& ident, Operator oper, ExpressionNode*  right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableExpressionData(divot, startOffset, endOffset)
         , m_ident(ident)
         , m_right(right)
@@ -591,16 +591,16 @@ namespace JSC {
     {
     }
 
-    inline AssignResolveNode::AssignResolveNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments)
-        : ExpressionNode(globalData)
+    inline AssignResolveNode::AssignResolveNode(int lineNumber, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments)
+        : ExpressionNode(lineNumber)
         , m_ident(ident)
         , m_right(right)
         , m_rightHasAssignments(rightHasAssignments)
     {
     }
 
-    inline ReadModifyBracketNode::ReadModifyBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline ReadModifyBracketNode::ReadModifyBracketNode(int lineNumber, ExpressionNode* base, ExpressionNode* subscript, Operator oper, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableSubExpressionData(divot, startOffset, endOffset)
         , m_base(base)
         , m_subscript(subscript)
@@ -611,8 +611,8 @@ namespace JSC {
     {
     }
 
-    inline AssignBracketNode::AssignBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline AssignBracketNode::AssignBracketNode(int lineNumber, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableExpressionData(divot, startOffset, endOffset)
         , m_base(base)
         , m_subscript(subscript)
@@ -622,8 +622,8 @@ namespace JSC {
     {
     }
 
-    inline AssignDotNode::AssignDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline AssignDotNode::AssignDotNode(int lineNumber, ExpressionNode* base, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableExpressionData(divot, startOffset, endOffset)
         , m_base(base)
         , m_ident(ident)
@@ -632,8 +632,8 @@ namespace JSC {
     {
     }
 
-    inline ReadModifyDotNode::ReadModifyDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline ReadModifyDotNode::ReadModifyDotNode(int lineNumber, ExpressionNode* base, const Identifier& ident, Operator oper, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableSubExpressionData(divot, startOffset, endOffset)
         , m_base(base)
         , m_ident(ident)
@@ -643,8 +643,8 @@ namespace JSC {
     {
     }
 
-    inline AssignErrorNode::AssignErrorNode(JSGlobalData* globalData, ExpressionNode* left, Operator oper, ExpressionNode* right, unsigned divot, unsigned startOffset, unsigned endOffset)
-        : ExpressionNode(globalData)
+    inline AssignErrorNode::AssignErrorNode(int lineNumber, ExpressionNode* left, Operator oper, ExpressionNode* right, unsigned divot, unsigned startOffset, unsigned endOffset)
+        : ExpressionNode(lineNumber)
         , ThrowableExpressionData(divot, startOffset, endOffset)
         , m_left(left)
         , m_operator(oper)
@@ -652,74 +652,74 @@ namespace JSC {
     {
     }
 
-    inline CommaNode::CommaNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2)
-        : ExpressionNode(globalData)
+    inline CommaNode::CommaNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2)
+        : ExpressionNode(lineNumber)
     {
         m_expressions.append(expr1);
         m_expressions.append(expr2);
     }
 
-    inline ConstStatementNode::ConstStatementNode(JSGlobalData* globalData, ConstDeclNode* next)
-        : StatementNode(globalData)
+    inline ConstStatementNode::ConstStatementNode(int lineNumber, ConstDeclNode* next)
+        : StatementNode(lineNumber)
         , m_next(next)
     {
     }
 
-    inline SourceElements::SourceElements(JSGlobalData*)
+    inline SourceElements::SourceElements()
     {
     }
 
-    inline EmptyStatementNode::EmptyStatementNode(JSGlobalData* globalData)
-        : StatementNode(globalData)
+    inline EmptyStatementNode::EmptyStatementNode(int lineNumber)
+        : StatementNode(lineNumber)
     {
     }
 
-    inline DebuggerStatementNode::DebuggerStatementNode(JSGlobalData* globalData)
-        : StatementNode(globalData)
+    inline DebuggerStatementNode::DebuggerStatementNode(int lineNumber)
+        : StatementNode(lineNumber)
     {
     }
     
-    inline ExprStatementNode::ExprStatementNode(JSGlobalData* globalData, ExpressionNode* expr)
-        : StatementNode(globalData)
+    inline ExprStatementNode::ExprStatementNode(int lineNumber, ExpressionNode* expr)
+        : StatementNode(lineNumber)
         , m_expr(expr)
     {
     }
 
-    inline VarStatementNode::VarStatementNode(JSGlobalData* globalData, ExpressionNode* expr)
-        : StatementNode(globalData)
+    inline VarStatementNode::VarStatementNode(int lineNumber, ExpressionNode* expr)
+        : StatementNode(lineNumber)
         , m_expr(expr)
     {
     }
     
-    inline IfNode::IfNode(JSGlobalData* globalData, ExpressionNode* condition, StatementNode* ifBlock)
-        : StatementNode(globalData)
+    inline IfNode::IfNode(int lineNumber, ExpressionNode* condition, StatementNode* ifBlock)
+        : StatementNode(lineNumber)
         , m_condition(condition)
         , m_ifBlock(ifBlock)
     {
     }
 
-    inline IfElseNode::IfElseNode(JSGlobalData* globalData, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock)
-        : IfNode(globalData, condition, ifBlock)
+    inline IfElseNode::IfElseNode(int lineNumber, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock)
+        : IfNode(lineNumber, condition, ifBlock)
         , m_elseBlock(elseBlock)
     {
     }
 
-    inline DoWhileNode::DoWhileNode(JSGlobalData* globalData, StatementNode* statement, ExpressionNode* expr)
-        : StatementNode(globalData)
+    inline DoWhileNode::DoWhileNode(int lineNumber, StatementNode* statement, ExpressionNode* expr)
+        : StatementNode(lineNumber)
         , m_statement(statement)
         , m_expr(expr)
     {
     }
 
-    inline WhileNode::WhileNode(JSGlobalData* globalData, ExpressionNode* expr, StatementNode* statement)
-        : StatementNode(globalData)
+    inline WhileNode::WhileNode(int lineNumber, ExpressionNode* expr, StatementNode* statement)
+        : StatementNode(lineNumber)
         , m_expr(expr)
         , m_statement(statement)
     {
     }
 
-    inline ForNode::ForNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement, bool expr1WasVarDecl)
-        : StatementNode(globalData)
+    inline ForNode::ForNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement, bool expr1WasVarDecl)
+        : StatementNode(lineNumber)
         , m_expr1(expr1)
         , m_expr2(expr2)
         , m_expr3(expr3)
@@ -729,38 +729,38 @@ namespace JSC {
         ASSERT(statement);
     }
 
-    inline ContinueNode::ContinueNode(JSGlobalData* globalData)
-        : StatementNode(globalData)
+    inline ContinueNode::ContinueNode(JSGlobalData* globalData, int lineNumber)
+        : StatementNode(lineNumber)
         , m_ident(globalData->propertyNames->nullIdentifier)
     {
     }
 
-    inline ContinueNode::ContinueNode(JSGlobalData* globalData, const Identifier& ident)
-        : StatementNode(globalData)
+    inline ContinueNode::ContinueNode(int lineNumber, const Identifier& ident)
+        : StatementNode(lineNumber)
         , m_ident(ident)
     {
     }
     
-    inline BreakNode::BreakNode(JSGlobalData* globalData)
-        : StatementNode(globalData)
+    inline BreakNode::BreakNode(JSGlobalData* globalData, int lineNumber)
+        : StatementNode(lineNumber)
         , m_ident(globalData->propertyNames->nullIdentifier)
     {
     }
 
-    inline BreakNode::BreakNode(JSGlobalData* globalData, const Identifier& ident)
-        : StatementNode(globalData)
+    inline BreakNode::BreakNode(int lineNumber, const Identifier& ident)
+        : StatementNode(lineNumber)
         , m_ident(ident)
     {
     }
     
-    inline ReturnNode::ReturnNode(JSGlobalData* globalData, ExpressionNode* value)
-        : StatementNode(globalData)
+    inline ReturnNode::ReturnNode(int lineNumber, ExpressionNode* value)
+        : StatementNode(lineNumber)
         , m_value(value)
     {
     }
 
-    inline WithNode::WithNode(JSGlobalData* globalData, ExpressionNode* expr, StatementNode* statement, uint32_t divot, uint32_t expressionLength)
-        : StatementNode(globalData)
+    inline WithNode::WithNode(int lineNumber, ExpressionNode* expr, StatementNode* statement, uint32_t divot, uint32_t expressionLength)
+        : StatementNode(lineNumber)
         , m_expr(expr)
         , m_statement(statement)
         , m_divot(divot)
@@ -768,21 +768,21 @@ namespace JSC {
     {
     }
 
-    inline LabelNode::LabelNode(JSGlobalData* globalData, const Identifier& name, StatementNode* statement)
-        : StatementNode(globalData)
+    inline LabelNode::LabelNode(int lineNumber, const Identifier& name, StatementNode* statement)
+        : StatementNode(lineNumber)
         , m_name(name)
         , m_statement(statement)
     {
     }
 
-    inline ThrowNode::ThrowNode(JSGlobalData* globalData, ExpressionNode* expr)
-        : StatementNode(globalData)
+    inline ThrowNode::ThrowNode(int lineNumber, ExpressionNode* expr)
+        : StatementNode(lineNumber)
         , m_expr(expr)
     {
     }
 
-    inline TryNode::TryNode(JSGlobalData* globalData, StatementNode* tryBlock, const Identifier& exceptionIdent, bool catchHasEval, StatementNode* catchBlock, StatementNode* finallyBlock)
-        : StatementNode(globalData)
+    inline TryNode::TryNode(int lineNumber, StatementNode* tryBlock, const Identifier& exceptionIdent, bool catchHasEval, StatementNode* catchBlock, StatementNode* finallyBlock)
+        : StatementNode(lineNumber)
         , m_tryBlock(tryBlock)
         , m_exceptionIdent(exceptionIdent)
         , m_catchBlock(catchBlock)
@@ -791,82 +791,82 @@ namespace JSC {
     {
     }
 
-    inline ParameterNode::ParameterNode(JSGlobalData*, const Identifier& ident)
+    inline ParameterNode::ParameterNode(const Identifier& ident)
         : m_ident(ident)
         , m_next(0)
     {
     }
 
-    inline ParameterNode::ParameterNode(JSGlobalData*, ParameterNode* l, const Identifier& ident)
+    inline ParameterNode::ParameterNode(ParameterNode* l, const Identifier& ident)
         : m_ident(ident)
         , m_next(0)
     {
         l->m_next = this;
     }
 
-    inline FuncExprNode::FuncExprNode(JSGlobalData* globalData, const Identifier& ident, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter)
-        : ExpressionNode(globalData)
+    inline FuncExprNode::FuncExprNode(int lineNumber, const Identifier& ident, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter)
+        : ExpressionNode(lineNumber)
         , m_body(body)
     {
         m_body->finishParsing(source, parameter, ident);
     }
 
-    inline FuncDeclNode::FuncDeclNode(JSGlobalData* globalData, const Identifier& ident, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter)
-        : StatementNode(globalData)
+    inline FuncDeclNode::FuncDeclNode(int lineNumber, const Identifier& ident, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter)
+        : StatementNode(lineNumber)
         , m_body(body)
     {
         m_body->finishParsing(source, parameter, ident);
     }
 
-    inline CaseClauseNode::CaseClauseNode(JSGlobalData*, ExpressionNode* expr, SourceElements* statements)
+    inline CaseClauseNode::CaseClauseNode(ExpressionNode* expr, SourceElements* statements)
         : m_expr(expr)
         , m_statements(statements)
     {
     }
 
-    inline ClauseListNode::ClauseListNode(JSGlobalData*, CaseClauseNode* clause)
+    inline ClauseListNode::ClauseListNode(CaseClauseNode* clause)
         : m_clause(clause)
         , m_next(0)
     {
     }
 
-    inline ClauseListNode::ClauseListNode(JSGlobalData*, ClauseListNode* clauseList, CaseClauseNode* clause)
+    inline ClauseListNode::ClauseListNode(ClauseListNode* clauseList, CaseClauseNode* clause)
         : m_clause(clause)
         , m_next(0)
     {
         clauseList->m_next = this;
     }
 
-    inline CaseBlockNode::CaseBlockNode(JSGlobalData*, ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2)
+    inline CaseBlockNode::CaseBlockNode(ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2)
         : m_list1(list1)
         , m_defaultClause(defaultClause)
         , m_list2(list2)
     {
     }
 
-    inline SwitchNode::SwitchNode(JSGlobalData* globalData, ExpressionNode* expr, CaseBlockNode* block)
-        : StatementNode(globalData)
+    inline SwitchNode::SwitchNode(int lineNumber, ExpressionNode* expr, CaseBlockNode* block)
+        : StatementNode(lineNumber)
         , m_expr(expr)
         , m_block(block)
     {
     }
 
-    inline ConstDeclNode::ConstDeclNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* init)
-        : ExpressionNode(globalData)
+    inline ConstDeclNode::ConstDeclNode(int lineNumber, const Identifier& ident, ExpressionNode* init)
+        : ExpressionNode(lineNumber)
         , m_ident(ident)
         , m_next(0)
         , m_init(init)
     {
     }
 
-    inline BlockNode::BlockNode(JSGlobalData* globalData, SourceElements* statements)
-        : StatementNode(globalData)
+    inline BlockNode::BlockNode(int lineNumber, SourceElements* statements)
+        : StatementNode(lineNumber)
         , m_statements(statements)
     {
     }
 
-    inline ForInNode::ForInNode(JSGlobalData* globalData, ExpressionNode* l, ExpressionNode* expr, StatementNode* statement)
-        : StatementNode(globalData)
+    inline ForInNode::ForInNode(JSGlobalData* globalData, int lineNumber, ExpressionNode* l, ExpressionNode* expr, StatementNode* statement)
+        : StatementNode(lineNumber)
         , m_ident(globalData->propertyNames->nullIdentifier)
         , m_init(0)
         , m_lexpr(l)
@@ -876,17 +876,17 @@ namespace JSC {
     {
     }
 
-    inline ForInNode::ForInNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* in, ExpressionNode* expr, StatementNode* statement, int divot, int startOffset, int endOffset)
-        : StatementNode(globalData)
+    inline ForInNode::ForInNode(JSGlobalData* globalData, int lineNumber, const Identifier& ident, ExpressionNode* in, ExpressionNode* expr, StatementNode* statement, int divot, int startOffset, int endOffset)
+        : StatementNode(lineNumber)
         , m_ident(ident)
         , m_init(0)
-        , m_lexpr(new (globalData) ResolveNode(globalData, ident, divot - startOffset))
+        , m_lexpr(new (globalData) ResolveNode(lineNumber, ident, divot - startOffset))
         , m_expr(expr)
         , m_statement(statement)
         , m_identIsVarDecl(true)
     {
         if (in) {
-            AssignResolveNode* node = new (globalData) AssignResolveNode(globalData, ident, in, true);
+            AssignResolveNode* node = new (globalData) AssignResolveNode(lineNumber, ident, in, true);
             node->setExceptionSourceCode(divot, divot - startOffset, endOffset - divot);
             m_init = node;
         }
index 7f4deff..4853aec 100644 (file)
@@ -21,7 +21,6 @@
 #define NodeInfo_h
 
 #include "Nodes.h"
-#include "Parser.h"
 
 namespace JSC {
 
index 34aa674..8ad474e 100644 (file)
@@ -54,7 +54,7 @@ namespace JSC {
 
 void StatementNode::setLoc(int firstLine, int lastLine)
 {
-    m_line = firstLine;
+    m_lineNumber = firstLine;
     m_lastLine = lastLine;
 }
 
@@ -89,17 +89,17 @@ ScopeNodeData::ScopeNodeData(ParserArena& arena, SourceElements* statements, Var
 
 // ------------------------------ ScopeNode -----------------------------
 
-ScopeNode::ScopeNode(JSGlobalData* globalData, bool inStrictContext)
-    : StatementNode(globalData)
+ScopeNode::ScopeNode(JSGlobalData* globalData, int lineNumber, bool inStrictContext)
+    : StatementNode(lineNumber)
     , ParserArenaRefCounted(globalData)
     , m_features(inStrictContext ? StrictModeFeature : NoFeatures)
 {
 }
 
-ScopeNode::ScopeNode(JSGlobalData* globalData, const SourceCode& source, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, CodeFeatures features, int numConstants)
-    : StatementNode(globalData)
+ScopeNode::ScopeNode(JSGlobalData* globalData, int lineNumber, const SourceCode& source, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, CodeFeatures features, int numConstants)
+    : StatementNode(lineNumber)
     , ParserArenaRefCounted(globalData)
-    , m_data(adoptPtr(new ScopeNodeData(globalData->parser->arena(), children, varStack, funcStack, capturedVariables, numConstants)))
+    , m_data(adoptPtr(new ScopeNodeData(*globalData->parserArena, children, varStack, funcStack, capturedVariables, numConstants)))
     , m_features(features)
     , m_source(source)
 {
@@ -112,14 +112,14 @@ StatementNode* ScopeNode::singleStatement() const
 
 // ------------------------------ ProgramNode -----------------------------
 
-inline ProgramNode::ProgramNode(JSGlobalData* globalData, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
-    : ScopeNode(globalData, source, children, varStack, funcStack, capturedVariables, features, numConstants)
+inline ProgramNode::ProgramNode(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
+    : ScopeNode(globalData, lineNumber, source, children, varStack, funcStack, capturedVariables, features, numConstants)
 {
 }
 
-PassRefPtr<ProgramNode> ProgramNode::create(JSGlobalData* globalData, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
+PassRefPtr<ProgramNode> ProgramNode::create(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
 {
-    RefPtr<ProgramNode> node = new ProgramNode(globalData, children, varStack, funcStack, capturedVariables, source, features, numConstants);
+    RefPtr<ProgramNode> node = new ProgramNode(globalData, lineNumber, children, varStack, funcStack,  capturedVariables, source, features, numConstants);
 
     ASSERT(node->data()->m_arena.last() == node);
     node->data()->m_arena.removeLast();
@@ -130,14 +130,14 @@ PassRefPtr<ProgramNode> ProgramNode::create(JSGlobalData* globalData, SourceElem
 
 // ------------------------------ EvalNode -----------------------------
 
-inline EvalNode::EvalNode(JSGlobalData* globalData, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
-    : ScopeNode(globalData, source, children, varStack, funcStack, capturedVariables, features, numConstants)
+inline EvalNode::EvalNode(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
+    : ScopeNode(globalData, lineNumber, source, children, varStack, funcStack, capturedVariables, features, numConstants)
 {
 }
 
-PassRefPtr<EvalNode> EvalNode::create(JSGlobalData* globalData, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
+PassRefPtr<EvalNode> EvalNode::create(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
 {
-    RefPtr<EvalNode> node = new EvalNode(globalData, children, varStack, funcStack, capturedVariables, source, features, numConstants);
+    RefPtr<EvalNode> node = new EvalNode(globalData, lineNumber, children, varStack, funcStack, capturedVariables, source, features, numConstants);
 
     ASSERT(node->data()->m_arena.last() == node);
     node->data()->m_arena.removeLast();
@@ -154,13 +154,13 @@ FunctionParameters::FunctionParameters(ParameterNode* firstParameter)
         append(parameter->ident());
 }
 
-inline FunctionBodyNode::FunctionBodyNode(JSGlobalData* globalData, bool inStrictContext)
-    : ScopeNode(globalData, inStrictContext)
+inline FunctionBodyNode::FunctionBodyNode(JSGlobalData* globalData, int lineNumber, bool inStrictContext)
+    : ScopeNode(globalData, lineNumber, inStrictContext)
 {
 }
 
-inline FunctionBodyNode::FunctionBodyNode(JSGlobalData* globalData, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& sourceCode, CodeFeatures features, int numConstants)
-    : ScopeNode(globalData, sourceCode, children, varStack, funcStack, capturedVariables, features, numConstants)
+inline FunctionBodyNode::FunctionBodyNode(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& sourceCode, CodeFeatures features, int numConstants)
+    : ScopeNode(globalData, lineNumber, sourceCode, children, varStack, funcStack, capturedVariables, features, numConstants)
 {
 }
 
@@ -177,14 +177,14 @@ void FunctionBodyNode::finishParsing(PassRefPtr<FunctionParameters> parameters,
     m_ident = ident;
 }
 
-FunctionBodyNode* FunctionBodyNode::create(JSGlobalData* globalData, bool inStrictContext)
+FunctionBodyNode* FunctionBodyNode::create(JSGlobalData* globalData, int lineNumber, bool inStrictContext)
 {
-    return new FunctionBodyNode(globalData, inStrictContext);
+    return new FunctionBodyNode(globalData, lineNumber, inStrictContext);
 }
 
-PassRefPtr<FunctionBodyNode> FunctionBodyNode::create(JSGlobalData* globalData, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& sourceCode, CodeFeatures features, int numConstants)
+PassRefPtr<FunctionBodyNode> FunctionBodyNode::create(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& sourceCode, CodeFeatures features, int numConstants)
 {
-    RefPtr<FunctionBodyNode> node = new FunctionBodyNode(globalData, children, varStack, funcStack, capturedVariables, sourceCode, features, numConstants);
+    RefPtr<FunctionBodyNode> node = new FunctionBodyNode(globalData, lineNumber, children, varStack, funcStack, capturedVariables, sourceCode, features, numConstants);
 
     ASSERT(node->data()->m_arena.last() == node);
     node->data()->m_arena.removeLast();
index 887eb06..23f2cde 100644 (file)
@@ -115,6 +115,11 @@ namespace JSC {
         void* operator new(size_t, JSGlobalData*);
     };
 
+    template <typename T>
+    struct ParserArenaData : ParserArenaDeletable {
+        T data;
+    };
+
     class ParserArenaRefCounted : public RefCounted<ParserArenaRefCounted> {
     protected:
         ParserArenaRefCounted(JSGlobalData*);
@@ -128,22 +133,22 @@ namespace JSC {
 
     class Node : public ParserArenaFreeable {
     protected:
-        Node(JSGlobalData*);
+        Node(int);
 
     public:
         virtual ~Node() { }
 
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* destination = 0) = 0;
 
-        int lineNo() const { return m_line; }
+        int lineNo() const { return m_lineNumber; }
 
     protected:
-        int m_line;
+        int m_lineNumber;
     };
 
     class ExpressionNode : public Node {
     protected:
-        ExpressionNode(JSGlobalData*, ResultType = ResultType::unknownType());
+        ExpressionNode(int, ResultType = ResultType::unknownType());
 
     public:
         virtual bool isNumber() const { return false; }
@@ -173,7 +178,7 @@ namespace JSC {
 
     class StatementNode : public Node {
     protected:
-        StatementNode(JSGlobalData*);
+        StatementNode(int);
 
     public:
         void setLoc(int firstLine, int lastLine);
@@ -192,7 +197,7 @@ namespace JSC {
 
     class NullNode : public ExpressionNode {
     public:
-        NullNode(JSGlobalData*);
+        NullNode(int);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -202,7 +207,7 @@ namespace JSC {
 
     class BooleanNode : public ExpressionNode {
     public:
-        BooleanNode(JSGlobalData*, bool value);
+        BooleanNode(int, bool value);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -214,7 +219,7 @@ namespace JSC {
 
     class NumberNode : public ExpressionNode {
     public:
-        NumberNode(JSGlobalData*, double value);
+        NumberNode(int, double value);
 
         double value() const { return m_value; }
         void setValue(double value) { m_value = value; }
@@ -230,7 +235,7 @@ namespace JSC {
 
     class StringNode : public ExpressionNode {
     public:
-        StringNode(JSGlobalData*, const Identifier&);
+        StringNode(int, const Identifier&);
 
         const Identifier& value() { return m_value; }
 
@@ -340,7 +345,7 @@ namespace JSC {
 
     class RegExpNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        RegExpNode(JSGlobalData*, const Identifier& pattern, const Identifier& flags);
+        RegExpNode(int, const Identifier& pattern, const Identifier& flags);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -351,7 +356,7 @@ namespace JSC {
 
     class ThisNode : public ExpressionNode {
     public:
-        ThisNode(JSGlobalData*);
+        ThisNode(int);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -359,7 +364,7 @@ namespace JSC {
 
     class ResolveNode : public ExpressionNode {
     public:
-        ResolveNode(JSGlobalData*, const Identifier&, int startOffset);
+        ResolveNode(int, const Identifier&, int startOffset);
 
         const Identifier& identifier() const { return m_ident; }
 
@@ -376,8 +381,8 @@ namespace JSC {
 
     class ElementNode : public ParserArenaFreeable {
     public:
-        ElementNode(JSGlobalData*, int elision, ExpressionNode*);
-        ElementNode(JSGlobalData*, ElementNode*, int elision, ExpressionNode*);
+        ElementNode(int elision, ExpressionNode*);
+        ElementNode(ElementNode*, int elision, ExpressionNode*);
 
         int elision() const { return m_elision; }
         ExpressionNode* value() { return m_node; }
@@ -391,11 +396,11 @@ namespace JSC {
 
     class ArrayNode : public ExpressionNode {
     public:
-        ArrayNode(JSGlobalData*, int elision);
-        ArrayNode(JSGlobalData*, ElementNode*);
-        ArrayNode(JSGlobalData*, int elision, ElementNode*);
+        ArrayNode(int, int elision);
+        ArrayNode(int, ElementNode*);
+        ArrayNode(int, int elision, ElementNode*);
 
-        ArgumentListNode* toArgumentList(JSGlobalData*) const;
+        ArgumentListNode* toArgumentList(JSGlobalData*, int) const;
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -411,8 +416,8 @@ namespace JSC {
     public:
         enum Type { Constant = 1, Getter = 2, Setter = 4 };
 
-        PropertyNode(JSGlobalData*, const Identifier& name, ExpressionNode* value, Type);
-        PropertyNode(JSGlobalData*, double name, ExpressionNode* value, Type);
+        PropertyNode(JSGlobalData*, const Identifier&, ExpressionNode*, Type);
+        PropertyNode(JSGlobalData*, double, ExpressionNode*, Type);
 
         const Identifier& name() const { return m_name; }
         Type type() const { return m_type; }
@@ -426,8 +431,8 @@ namespace JSC {
 
     class PropertyListNode : public Node {
     public:
-        PropertyListNode(JSGlobalData*, PropertyNode*);
-        PropertyListNode(JSGlobalData*, PropertyNode*, PropertyListNode*);
+        PropertyListNode(int, PropertyNode*);
+        PropertyListNode(int, PropertyNode*, PropertyListNode*);
 
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
 
@@ -438,8 +443,8 @@ namespace JSC {
 
     class ObjectLiteralNode : public ExpressionNode {
     public:
-        ObjectLiteralNode(JSGlobalData*);
-        ObjectLiteralNode(JSGlobalData*, PropertyListNode*);
+        ObjectLiteralNode(int);
+        ObjectLiteralNode(int, PropertyListNode*);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -449,7 +454,7 @@ namespace JSC {
     
     class BracketAccessorNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        BracketAccessorNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments);
+        BracketAccessorNode(int, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments);
 
         ExpressionNode* base() const { return m_base; }
         ExpressionNode* subscript() const { return m_subscript; }
@@ -467,7 +472,7 @@ namespace JSC {
 
     class DotAccessorNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        DotAccessorNode(JSGlobalData*, ExpressionNode* base, const Identifier&);
+        DotAccessorNode(int, ExpressionNode* base, const Identifier&);
 
         ExpressionNode* base() const { return m_base; }
         const Identifier& identifier() const { return m_ident; }
@@ -484,8 +489,8 @@ namespace JSC {
 
     class ArgumentListNode : public Node {
     public:
-        ArgumentListNode(JSGlobalData*, ExpressionNode*);
-        ArgumentListNode(JSGlobalData*, ArgumentListNode*, ExpressionNode*);
+        ArgumentListNode(int, ExpressionNode*);
+        ArgumentListNode(int, ArgumentListNode*, ExpressionNode*);
 
         ArgumentListNode* m_next;
         ExpressionNode* m_expr;
@@ -496,16 +501,16 @@ namespace JSC {
 
     class ArgumentsNode : public ParserArenaFreeable {
     public:
-        ArgumentsNode(JSGlobalData*);
-        ArgumentsNode(JSGlobalData*, ArgumentListNode*);
+        ArgumentsNode();
+        ArgumentsNode(ArgumentListNode*);
 
         ArgumentListNode* m_listNode;
     };
 
     class NewExprNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        NewExprNode(JSGlobalData*, ExpressionNode*);
-        NewExprNode(JSGlobalData*, ExpressionNode*, ArgumentsNode*);
+        NewExprNode(int, ExpressionNode*);
+        NewExprNode(int, ExpressionNode*, ArgumentsNode*);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -516,7 +521,7 @@ namespace JSC {
 
     class EvalFunctionCallNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        EvalFunctionCallNode(JSGlobalData*, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
+        EvalFunctionCallNode(int, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -526,7 +531,7 @@ namespace JSC {
 
     class FunctionCallValueNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        FunctionCallValueNode(JSGlobalData*, ExpressionNode*, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
+        FunctionCallValueNode(int, ExpressionNode*, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -537,7 +542,7 @@ namespace JSC {
 
     class FunctionCallResolveNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        FunctionCallResolveNode(JSGlobalData*, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
+        FunctionCallResolveNode(int, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -550,7 +555,7 @@ namespace JSC {
     
     class FunctionCallBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
     public:
-        FunctionCallBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
+        FunctionCallBracketNode(int, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -562,7 +567,7 @@ namespace JSC {
 
     class FunctionCallDotNode : public ExpressionNode, public ThrowableSubExpressionData {
     public:
-        FunctionCallDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
+        FunctionCallDotNode(int, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -575,7 +580,7 @@ namespace JSC {
 
     class CallFunctionCallDotNode : public FunctionCallDotNode {
     public:
-        CallFunctionCallDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
+        CallFunctionCallDotNode(int, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -583,7 +588,7 @@ namespace JSC {
     
     class ApplyFunctionCallDotNode : public FunctionCallDotNode {
     public:
-        ApplyFunctionCallDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
+        ApplyFunctionCallDotNode(int, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -591,7 +596,7 @@ namespace JSC {
 
     class PrePostResolveNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        PrePostResolveNode(JSGlobalData*, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
+        PrePostResolveNode(int, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     protected:
         const Identifier& m_ident;
@@ -599,7 +604,7 @@ namespace JSC {
 
     class PostfixResolveNode : public PrePostResolveNode {
     public:
-        PostfixResolveNode(JSGlobalData*, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
+        PostfixResolveNode(int, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -609,7 +614,7 @@ namespace JSC {
 
     class PostfixBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
     public:
-        PostfixBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
+        PostfixBracketNode(int, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -621,7 +626,7 @@ namespace JSC {
 
     class PostfixDotNode : public ExpressionNode, public ThrowableSubExpressionData {
     public:
-        PostfixDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
+        PostfixDotNode(int, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -633,7 +638,7 @@ namespace JSC {
 
     class PostfixErrorNode : public ExpressionNode, public ThrowableSubExpressionData {
     public:
-        PostfixErrorNode(JSGlobalData*, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
+        PostfixErrorNode(int, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -644,7 +649,7 @@ namespace JSC {
 
     class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        DeleteResolveNode(JSGlobalData*, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
+        DeleteResolveNode(int, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -654,7 +659,7 @@ namespace JSC {
 
     class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        DeleteBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset);
+        DeleteBracketNode(int, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -665,7 +670,7 @@ namespace JSC {
 
     class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        DeleteDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
+        DeleteDotNode(int, ExpressionNode* base, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -676,7 +681,7 @@ namespace JSC {
 
     class DeleteValueNode : public ExpressionNode {
     public:
-        DeleteValueNode(JSGlobalData*, ExpressionNode*);
+        DeleteValueNode(int, ExpressionNode*);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -686,7 +691,7 @@ namespace JSC {
 
     class VoidNode : public ExpressionNode {
     public:
-        VoidNode(JSGlobalData*, ExpressionNode*);
+        VoidNode(int, ExpressionNode*);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -696,7 +701,7 @@ namespace JSC {
 
     class TypeOfResolveNode : public ExpressionNode {
     public:
-        TypeOfResolveNode(JSGlobalData*, const Identifier&);
+        TypeOfResolveNode(int, const Identifier&);
 
         const Identifier& identifier() const { return m_ident; }
 
@@ -708,7 +713,7 @@ namespace JSC {
 
     class TypeOfValueNode : public ExpressionNode {
     public:
-        TypeOfValueNode(JSGlobalData*, ExpressionNode*);
+        TypeOfValueNode(int, ExpressionNode*);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -718,7 +723,7 @@ namespace JSC {
 
     class PrefixResolveNode : public PrePostResolveNode {
     public:
-        PrefixResolveNode(JSGlobalData*, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
+        PrefixResolveNode(int, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -728,7 +733,7 @@ namespace JSC {
 
     class PrefixBracketNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
     public:
-        PrefixBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
+        PrefixBracketNode(int, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -740,7 +745,7 @@ namespace JSC {
 
     class PrefixDotNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
     public:
-        PrefixDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
+        PrefixDotNode(int, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -752,7 +757,7 @@ namespace JSC {
 
     class PrefixErrorNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        PrefixErrorNode(JSGlobalData*, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
+        PrefixErrorNode(int, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -763,7 +768,7 @@ namespace JSC {
 
     class UnaryOpNode : public ExpressionNode {
     public:
-        UnaryOpNode(JSGlobalData*, ResultType, ExpressionNode*, OpcodeID);
+        UnaryOpNode(int, ResultType, ExpressionNode*, OpcodeID);
 
     protected:
         ExpressionNode* expr() { return m_expr; }
@@ -780,7 +785,7 @@ namespace JSC {
 
     class UnaryPlusNode : public UnaryOpNode {
     public:
-        UnaryPlusNode(JSGlobalData*, ExpressionNode*);
+        UnaryPlusNode(int, ExpressionNode*);
 
     private:
         virtual ExpressionNode* stripUnaryPlus() { return expr(); }
@@ -788,17 +793,17 @@ namespace JSC {
 
     class NegateNode : public UnaryOpNode {
     public:
-        NegateNode(JSGlobalData*, ExpressionNode*);
+        NegateNode(int, ExpressionNode*);
     };
 
     class BitwiseNotNode : public UnaryOpNode {
     public:
-        BitwiseNotNode(JSGlobalData*, ExpressionNode*);
+        BitwiseNotNode(int, ExpressionNode*);
     };
 
     class LogicalNotNode : public UnaryOpNode {
     public:
-        LogicalNotNode(JSGlobalData*, ExpressionNode*);
+        LogicalNotNode(int, ExpressionNode*);
     private:
         void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, bool fallThroughMeansTrue);
         virtual bool hasConditionContextCodegen() const { return expr()->hasConditionContextCodegen(); }
@@ -806,8 +811,8 @@ namespace JSC {
 
     class BinaryOpNode : public ExpressionNode {
     public:
-        BinaryOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
-        BinaryOpNode(JSGlobalData*, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
+        BinaryOpNode(int, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
+        BinaryOpNode(int, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
 
         RegisterID* emitStrcat(BytecodeGenerator& generator, RegisterID* destination, RegisterID* lhs = 0, ReadModifyResolveNode* emitExpressionInfoForMe = 0);
 
@@ -831,72 +836,72 @@ namespace JSC {
 
     class MultNode : public BinaryOpNode {
     public:
-        MultNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        MultNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     };
 
     class DivNode : public BinaryOpNode {
     public:
-        DivNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        DivNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     };
 
     class ModNode : public BinaryOpNode {
     public:
-        ModNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        ModNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     };
 
     class AddNode : public BinaryOpNode {
     public:
-        AddNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        AddNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
 
         virtual bool isAdd() const { return true; }
     };
 
     class SubNode : public BinaryOpNode {
     public:
-        SubNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        SubNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
 
         virtual bool isSubtract() const { return true; }
     };
 
     class LeftShiftNode : public BinaryOpNode {
     public:
-        LeftShiftNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        LeftShiftNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     };
 
     class RightShiftNode : public BinaryOpNode {
     public:
-        RightShiftNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        RightShiftNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     };
 
     class UnsignedRightShiftNode : public BinaryOpNode {
     public:
-        UnsignedRightShiftNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        UnsignedRightShiftNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     };
 
     class LessNode : public BinaryOpNode {
     public:
-        LessNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        LessNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     };
 
     class GreaterNode : public BinaryOpNode {
     public:
-        GreaterNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        GreaterNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     };
 
     class LessEqNode : public BinaryOpNode {
     public:
-        LessEqNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        LessEqNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     };
 
     class GreaterEqNode : public BinaryOpNode {
     public:
-        GreaterEqNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        GreaterEqNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     };
 
     class ThrowableBinaryOpNode : public BinaryOpNode, public ThrowableExpressionData {
     public:
-        ThrowableBinaryOpNode(JSGlobalData*, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
-        ThrowableBinaryOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
+        ThrowableBinaryOpNode(int, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
+        ThrowableBinaryOpNode(int, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -904,7 +909,7 @@ namespace JSC {
     
     class InstanceOfNode : public ThrowableBinaryOpNode {
     public:
-        InstanceOfNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        InstanceOfNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -912,12 +917,12 @@ namespace JSC {
 
     class InNode : public ThrowableBinaryOpNode {
     public:
-        InNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        InNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     };
 
     class EqualNode : public BinaryOpNode {
     public:
-        EqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        EqualNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -925,12 +930,12 @@ namespace JSC {
 
     class NotEqualNode : public BinaryOpNode {
     public:
-        NotEqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        NotEqualNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     };
 
     class StrictEqualNode : public BinaryOpNode {
     public:
-        StrictEqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        StrictEqualNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -938,28 +943,28 @@ namespace JSC {
 
     class NotStrictEqualNode : public BinaryOpNode {
     public:
-        NotStrictEqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        NotStrictEqualNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     };
 
     class BitAndNode : public BinaryOpNode {
     public:
-        BitAndNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        BitAndNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     };
 
     class BitOrNode : public BinaryOpNode {
     public:
-        BitOrNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        BitOrNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     };
 
     class BitXOrNode : public BinaryOpNode {
     public:
-        BitXOrNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        BitXOrNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     };
 
     // m_expr1 && m_expr2, m_expr1 || m_expr2
     class LogicalOpNode : public ExpressionNode {
     public:
-        LogicalOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator);
+        LogicalOpNode(int, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -974,7 +979,7 @@ namespace JSC {
     // The ternary operator, "m_logical ? m_expr1 : m_expr2"
     class ConditionalNode : public ExpressionNode {
     public:
-        ConditionalNode(JSGlobalData*, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2);
+        ConditionalNode(int, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -986,7 +991,7 @@ namespace JSC {
 
     class ReadModifyResolveNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        ReadModifyResolveNode(JSGlobalData*, const Identifier&, Operator, ExpressionNode*  right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
+        ReadModifyResolveNode(int, const Identifier&, Operator, ExpressionNode*  right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1000,7 +1005,7 @@ namespace JSC {
 
     class AssignResolveNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        AssignResolveNode(JSGlobalData*, const Identifier&, ExpressionNode* right, bool rightHasAssignments);
+        AssignResolveNode(int, const Identifier&, ExpressionNode* right, bool rightHasAssignments);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1013,7 +1018,7 @@ namespace JSC {
 
     class ReadModifyBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
     public:
-        ReadModifyBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, Operator, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
+        ReadModifyBracketNode(int, ExpressionNode* base, ExpressionNode* subscript, Operator, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1028,7 +1033,7 @@ namespace JSC {
 
     class AssignBracketNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        AssignBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
+        AssignBracketNode(int, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1042,7 +1047,7 @@ namespace JSC {
 
     class AssignDotNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        AssignDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
+        AssignDotNode(int, ExpressionNode* base, const Identifier&, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1055,7 +1060,7 @@ namespace JSC {
 
     class ReadModifyDotNode : public ExpressionNode, public ThrowableSubExpressionData {
     public:
-        ReadModifyDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, Operator, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
+        ReadModifyDotNode(int, ExpressionNode* base, const Identifier&, Operator, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1069,7 +1074,7 @@ namespace JSC {
 
     class AssignErrorNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        AssignErrorNode(JSGlobalData*, ExpressionNode* left, Operator, ExpressionNode* right, unsigned divot, unsigned startOffset, unsigned endOffset);
+        AssignErrorNode(int, ExpressionNode* left, Operator, ExpressionNode* right, unsigned divot, unsigned startOffset, unsigned endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1083,7 +1088,7 @@ namespace JSC {
 
     class CommaNode : public ExpressionNode, public ParserArenaDeletable {
     public:
-        CommaNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2);
+        CommaNode(int, ExpressionNode* expr1, ExpressionNode* expr2);
 
         using ParserArenaDeletable::operator new;
 
@@ -1098,7 +1103,7 @@ namespace JSC {
     
     class ConstDeclNode : public ExpressionNode {
     public:
-        ConstDeclNode(JSGlobalData*, const Identifier&, ExpressionNode*);
+        ConstDeclNode(int, const Identifier&, ExpressionNode*);
 
         bool hasInitializer() const { return m_init; }
         const Identifier& ident() { return m_ident; }
@@ -1118,7 +1123,7 @@ namespace JSC {
 
     class ConstStatementNode : public StatementNode {
     public:
-        ConstStatementNode(JSGlobalData*, ConstDeclNode* next);
+        ConstStatementNode(int, ConstDeclNode* next);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1128,7 +1133,7 @@ namespace JSC {
 
     class SourceElements : public ParserArenaDeletable {
     public:
-        SourceElements(JSGlobalData*);
+        SourceElements();
 
         void append(StatementNode*);
 
@@ -1143,7 +1148,7 @@ namespace JSC {
 
     class BlockNode : public StatementNode {
     public:
-        BlockNode(JSGlobalData*, SourceElements* = 0);
+        BlockNode(int, SourceElements* = 0);
 
         StatementNode* singleStatement() const;
         StatementNode* lastStatement() const;
@@ -1158,7 +1163,7 @@ namespace JSC {
 
     class EmptyStatementNode : public StatementNode {
     public:
-        EmptyStatementNode(JSGlobalData*);
+        EmptyStatementNode(int);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1168,7 +1173,7 @@ namespace JSC {
     
     class DebuggerStatementNode : public StatementNode {
     public:
-        DebuggerStatementNode(JSGlobalData*);
+        DebuggerStatementNode(int);
         
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1176,7 +1181,7 @@ namespace JSC {
 
     class ExprStatementNode : public StatementNode {
     public:
-        ExprStatementNode(JSGlobalData*, ExpressionNode*);
+        ExprStatementNode(int, ExpressionNode*);
 
         ExpressionNode* expr() const { return m_expr; }
 
@@ -1190,7 +1195,7 @@ namespace JSC {
 
     class VarStatementNode : public StatementNode {
     public:
-        VarStatementNode(JSGlobalData*, ExpressionNode*);        
+        VarStatementNode(int, ExpressionNode*);        
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1200,7 +1205,7 @@ namespace JSC {
 
     class IfNode : public StatementNode {
     public:
-        IfNode(JSGlobalData*, ExpressionNode* condition, StatementNode* ifBlock);
+        IfNode(int, ExpressionNode* condition, StatementNode* ifBlock);
 
     protected:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1211,7 +1216,7 @@ namespace JSC {
 
     class IfElseNode : public IfNode {
     public:
-        IfElseNode(JSGlobalData*, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock);
+        IfElseNode(int, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1221,7 +1226,7 @@ namespace JSC {
 
     class DoWhileNode : public StatementNode {
     public:
-        DoWhileNode(JSGlobalData*, StatementNode* statement, ExpressionNode*);
+        DoWhileNode(int, StatementNode*, ExpressionNode*);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1232,7 +1237,7 @@ namespace JSC {
 
     class WhileNode : public StatementNode {
     public:
-        WhileNode(JSGlobalData*, ExpressionNode*, StatementNode* statement);
+        WhileNode(int, ExpressionNode*, StatementNode*);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1243,7 +1248,7 @@ namespace JSC {
 
     class ForNode : public StatementNode {
     public:
-        ForNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement, bool expr1WasVarDecl);
+        ForNode(int, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode*, bool expr1WasVarDecl);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1257,8 +1262,8 @@ namespace JSC {
 
     class ForInNode : public StatementNode, public ThrowableExpressionData {
     public:
-        ForInNode(JSGlobalData*, ExpressionNode*, ExpressionNode*, StatementNode*);
-        ForInNode(JSGlobalData*, const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*, int divot, int startOffset, int endOffset);
+        ForInNode(JSGlobalData*, int, ExpressionNode*, ExpressionNode*, StatementNode*);
+        ForInNode(JSGlobalData*, int, const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*, int divot, int startOffset, int endOffset);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1273,8 +1278,8 @@ namespace JSC {
 
     class ContinueNode : public StatementNode, public ThrowableExpressionData {
     public:
-        ContinueNode(JSGlobalData*);
-        ContinueNode(JSGlobalData*, const Identifier&);
+        ContinueNode(JSGlobalData*, int);
+        ContinueNode(int, const Identifier&);
         
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1284,8 +1289,8 @@ namespace JSC {
 
     class BreakNode : public StatementNode, public ThrowableExpressionData {
     public:
-        BreakNode(JSGlobalData*);
-        BreakNode(JSGlobalData*, const Identifier&);
+        BreakNode(JSGlobalData*, int);
+        BreakNode(int, const Identifier&);
         
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1295,7 +1300,7 @@ namespace JSC {
 
     class ReturnNode : public StatementNode, public ThrowableExpressionData {
     public:
-        ReturnNode(JSGlobalData*, ExpressionNode* value);
+        ReturnNode(int, ExpressionNode* value);
 
         ExpressionNode* value() { return m_value; }
 
@@ -1309,7 +1314,7 @@ namespace JSC {
 
     class WithNode : public StatementNode {
     public:
-        WithNode(JSGlobalData*, ExpressionNode*, StatementNode*, uint32_t divot, uint32_t expressionLength);
+        WithNode(int, ExpressionNode*, StatementNode*, uint32_t divot, uint32_t expressionLength);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1322,7 +1327,7 @@ namespace JSC {
 
     class LabelNode : public StatementNode, public ThrowableExpressionData {
     public:
-        LabelNode(JSGlobalData*, const Identifier& name, StatementNode*);
+        LabelNode(int, const Identifier& name, StatementNode*);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1333,7 +1338,7 @@ namespace JSC {
 
     class ThrowNode : public StatementNode, public ThrowableExpressionData {
     public:
-        ThrowNode(JSGlobalData*, ExpressionNode*);
+        ThrowNode(int, ExpressionNode*);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1343,7 +1348,7 @@ namespace JSC {
 
     class TryNode : public StatementNode {
     public:
-        TryNode(JSGlobalData*, StatementNode* tryBlock, const Identifier& exceptionIdent, bool catchHasEval, StatementNode* catchBlock, StatementNode* finallyBlock);
+        TryNode(int, StatementNode* tryBlock, const Identifier& exceptionIdent, bool catchHasEval, StatementNode* catchBlock, StatementNode* finallyBlock);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1357,8 +1362,8 @@ namespace JSC {
 
     class ParameterNode : public ParserArenaFreeable {
     public:
-        ParameterNode(JSGlobalData*, const Identifier&);
-        ParameterNode(JSGlobalData*, ParameterNode*, const Identifier&);
+        ParameterNode(const Identifier&);
+        ParameterNode(ParameterNode*, const Identifier&);
 
         const Identifier& ident() const { return m_ident; }
         ParameterNode* nextParam() const { return m_next; }
@@ -1389,8 +1394,8 @@ namespace JSC {
         typedef DeclarationStacks::VarStack VarStack;
         typedef DeclarationStacks::FunctionStack FunctionStack;
 
-        ScopeNode(JSGlobalData*, bool inStrictContext);
-        ScopeNode(JSGlobalData*, const SourceCode&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, CodeFeatures, int numConstants);
+        ScopeNode(JSGlobalData*, int, bool inStrictContext);
+        ScopeNode(JSGlobalData*, int, const SourceCode&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, CodeFeatures, int numConstants);
 
         using ParserArenaRefCounted::operator new;
 
@@ -1442,12 +1447,12 @@ namespace JSC {
     class ProgramNode : public ScopeNode {
     public:
         static const bool isFunctionNode = false;
-        static PassRefPtr<ProgramNode> create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
+        static PassRefPtr<ProgramNode> create(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
 
         static const bool scopeIsFunction = false;
 
     private:
-        ProgramNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
+        ProgramNode(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
 
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
     };
@@ -1455,12 +1460,12 @@ namespace JSC {
     class EvalNode : public ScopeNode {
     public:
         static const bool isFunctionNode = false;
-        static PassRefPtr<EvalNode> create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
+        static PassRefPtr<EvalNode> create(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
 
         static const bool scopeIsFunction = false;
 
     private:
-        EvalNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
+        EvalNode(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
 
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
     };
@@ -1477,8 +1482,8 @@ namespace JSC {
     class FunctionBodyNode : public ScopeNode {
     public:
         static const bool isFunctionNode = true;
-        static FunctionBodyNode* create(JSGlobalData*, bool isStrictMode);
-        static PassRefPtr<FunctionBodyNode> create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
+        static FunctionBodyNode* create(JSGlobalData*, int, bool isStrictMode);
+        static PassRefPtr<FunctionBodyNode> create(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
 
         FunctionParameters* parameters() const { return m_parameters.get(); }
         size_t parameterCount() const { return m_parameters->size(); }
@@ -1493,8 +1498,8 @@ namespace JSC {
         static const bool scopeIsFunction = true;
 
     private:
-        FunctionBodyNode(JSGlobalData*, bool inStrictContext);
-        FunctionBodyNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
+        FunctionBodyNode(JSGlobalData*, int, bool inStrictContext);
+        FunctionBodyNode(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
 
         Identifier m_ident;
         RefPtr<FunctionParameters> m_parameters;
@@ -1502,7 +1507,7 @@ namespace JSC {
 
     class FuncExprNode : public ExpressionNode {
     public:
-        FuncExprNode(JSGlobalData*, const Identifier&, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter = 0);
+        FuncExprNode(int, const Identifier&, FunctionBodyNode*, const SourceCode&, ParameterNode* = 0);
 
         FunctionBodyNode* body() { return m_body; }
 
@@ -1516,7 +1521,7 @@ namespace JSC {
 
     class FuncDeclNode : public StatementNode {
     public:
-        FuncDeclNode(JSGlobalData*, const Identifier&, FunctionBodyNode*, const SourceCode&, ParameterNode* = 0);
+        FuncDeclNode(int, const Identifier&, FunctionBodyNode*, const SourceCode&, ParameterNode* = 0);
 
         FunctionBodyNode* body() { return m_body; }
 
@@ -1528,7 +1533,7 @@ namespace JSC {
 
     class CaseClauseNode : public ParserArenaFreeable {
     public:
-        CaseClauseNode(JSGlobalData*, ExpressionNode*, SourceElements* = 0);
+        CaseClauseNode(ExpressionNode*, SourceElements* = 0);
 
         ExpressionNode* expr() const { return m_expr; }
 
@@ -1541,8 +1546,8 @@ namespace JSC {
 
     class ClauseListNode : public ParserArenaFreeable {
     public:
-        ClauseListNode(JSGlobalData*, CaseClauseNode*);
-        ClauseListNode(JSGlobalData*, ClauseListNode*, CaseClauseNode*);
+        ClauseListNode(CaseClauseNode*);
+        ClauseListNode(ClauseListNode*, CaseClauseNode*);
 
         CaseClauseNode* getClause() const { return m_clause; }
         ClauseListNode* getNext() const { return m_next; }
@@ -1554,7 +1559,7 @@ namespace JSC {
 
     class CaseBlockNode : public ParserArenaFreeable {
     public:
-        CaseBlockNode(JSGlobalData*, ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2);
+        CaseBlockNode(ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2);
 
         RegisterID* emitBytecodeForBlock(BytecodeGenerator&, RegisterID* input, RegisterID* destination);
 
@@ -1567,7 +1572,7 @@ namespace JSC {
 
     class SwitchNode : public StatementNode {
     public:
-        SwitchNode(JSGlobalData*, ExpressionNode*, CaseBlockNode*);
+        SwitchNode(int, ExpressionNode*, CaseBlockNode*);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
index bc8e66d..24c873e 100644 (file)
 #include "config.h"
 #include "Parser.h"
 
+#include "ASTBuilder.h"
+#include "CodeBlock.h"
 #include "Debugger.h"
-#include "JSParser.h"
+#include "JSGlobalData.h"
 #include "Lexer.h"
+#include "NodeInfo.h"
+#include "SourceProvider.h"
+#include "SourceProviderCacheItem.h"
+#include <utility>
+#include <wtf/HashFunctions.h>
+#include <wtf/OwnPtr.h>
+#include <wtf/WTFThreadData.h>
+
+using namespace std;
 
 namespace JSC {
 
-void Parser::parse(JSGlobalData* globalData, FunctionParameters* parameters, JSParserStrictness strictness, JSParserMode mode, int* errLine, UString* errMsg)
+Parser::Parser(JSGlobalData* globalData, const SourceCode& source, FunctionParameters* parameters, JSParserStrictness strictness, JSParserMode parserMode)
+    : m_globalData(globalData)
+    , m_source(&source)
+    , m_stack(globalData->stack())
+    , m_error(false)
+    , m_errorMessage("Parse error")
+    , m_allowsIn(true)
+    , m_lastLine(0)
+    , m_lastTokenEnd(0)
+    , m_assignmentCount(0)
+    , m_nonLHSCount(0)
+    , m_syntaxAlreadyValidated(source.provider()->isValid())
+    , m_statementDepth(0)
+    , m_nonTrivialExpressionCount(0)
+    , m_lastIdentifier(0)
+    , m_sourceElements(0)
 {
-    ASSERT(globalData);
-    m_sourceElements = 0;
+    m_lexer = new Lexer(globalData);
+    m_arena = m_globalData->parserArena;
+    m_lexer->setCode(source, m_arena);
 
-    int defaultErrLine;
-    UString defaultErrMsg;
+    m_functionCache = source.provider()->cache();
+    ScopeRef scope = pushScope();
+    if (parserMode == JSParseFunctionCode)
+        scope->setIsFunction();
+    if (strictness == JSParseStrict)
+        scope->setStrictMode();
+    if (parameters) {
+        for (unsigned i = 0; i < parameters->size(); i++)
+            scope->declareParameter(&parameters->at(i));
+    }
+    next();
+    m_lexer->setLastLineNumber(tokenLine());
+}
 
-    if (!errLine)
-        errLine = &defaultErrLine;
-    if (!errMsg)
-        errMsg = &defaultErrMsg;
+Parser::~Parser()
+{
+}
 
-    *errLine = -1;
-    *errMsg = UString();
 
-    Lexer& lexer = *globalData->lexer;
-    lexer.setCode(*m_source, m_arena);
+UString Parser::parseInner()
+{
+    UString parseError = UString();
+    
+    unsigned oldFunctionCacheSize = m_functionCache ? m_functionCache->byteSize() : 0;
+    ASTBuilder context(const_cast<JSGlobalData*>(m_globalData), const_cast<SourceCode*>(m_source));
+    if (m_lexer->isReparsing())
+        m_statementDepth--;
+    ScopeRef scope = currentScope();
+    SourceElements* sourceElements = parseSourceElements<CheckForStrictMode>(context);
+    if (!sourceElements || !consume(EOFTOK))
+        parseError = m_errorMessage;
 
-    UString parseError = jsParse(globalData, parameters, strictness, mode, m_source);
-    int lineNumber = lexer.lineNumber();
-    bool lexError = lexer.sawError();
-    UString lexErrorMessage = lexError ? lexer.getErrorMessage() : UString();
-    ASSERT(lexErrorMessage.isNull() != lexError);
-    lexer.clear();
+    IdentifierSet capturedVariables;
+    scope->getCapturedVariables(capturedVariables);
+    CodeFeatures features = context.features();
+    if (scope->strictMode())
+        features |= StrictModeFeature;
+    if (scope->shadowsArguments())
+        features |= ShadowsArgumentsFeature;
+    unsigned functionCacheSize = m_functionCache ? m_functionCache->byteSize() : 0;
+    if (functionCacheSize != oldFunctionCacheSize)
+        m_lexer->sourceProvider()->notifyCacheSizeChanged(functionCacheSize - oldFunctionCacheSize);
 
-    if (!parseError.isNull() || lexError) {
-        *errLine = lineNumber;
-        *errMsg = !lexErrorMessage.isNull() ? lexErrorMessage : parseError;
-        m_sourceElements = 0;
-    }
+    didFinishParsing(sourceElements, context.varDeclarations(), context.funcDeclarations(), features,
+                     m_lastLine, context.numConstants(), capturedVariables);
+
+    return parseError;
 }
 
 void Parser::didFinishParsing(SourceElements* sourceElements, ParserArenaData<DeclarationStacks::VarStack>* varStack, 
@@ -74,4 +122,1500 @@ void Parser::didFinishParsing(SourceElements* sourceElements, ParserArenaData<De
     m_numConstants = numConstants;
 }
 
+bool Parser::allowAutomaticSemicolon()
+{
+    return match(CLOSEBRACE) || match(EOFTOK) || m_lexer->prevTerminator();
+}
+
+template <Parser::SourceElementsMode mode, class TreeBuilder> TreeSourceElements Parser::parseSourceElements(TreeBuilder& context)
+{
+    TreeSourceElements sourceElements = context.createSourceElements();
+    bool seenNonDirective = false;
+    const Identifier* directive = 0;
+    unsigned startOffset = m_token.m_info.startOffset;
+    unsigned oldLastLineNumber = m_lexer->lastLineNumber();
+    unsigned oldLineNumber = m_lexer->lineNumber();
+    bool hasSetStrict = false;
+    while (TreeStatement statement = parseStatement(context, directive)) {
+        if (mode == CheckForStrictMode && !seenNonDirective) {
+            if (directive) {
+                if (!hasSetStrict && m_globalData->propertyNames->useStrictIdentifier == *directive) {
+                    setStrictMode();
+                    hasSetStrict = true;
+                    failIfFalse(isValidStrictMode());
+                    m_lexer->setOffset(startOffset);
+                    next();
+                    m_lexer->setLastLineNumber(oldLastLineNumber);
+                    m_lexer->setLineNumber(oldLineNumber);
+                    failIfTrue(m_error);
+                    continue;
+                }
+            } else
+                seenNonDirective = true;
+        }
+        context.appendStatement(sourceElements, statement);
+    }
+    
+    if (m_error)
+        fail();
+    return sourceElements;
+}
+
+template <class TreeBuilder> TreeStatement Parser::parseVarDeclaration(TreeBuilder& context)
+{
+    ASSERT(match(VAR));
+    int start = tokenLine();
+    int end = 0;
+    int scratch;
+    const Identifier* scratch1 = 0;
+    TreeExpression scratch2 = 0;
+    int scratch3 = 0;
+    TreeExpression varDecls = parseVarDeclarationList(context, scratch, scratch1, scratch2, scratch3, scratch3, scratch3);
+    failIfTrue(m_error);
+    failIfFalse(autoSemiColon());
+    
+    return context.createVarStatement(m_lexer->lastLineNumber(), varDecls, start, end);
+}
+
+template <class TreeBuilder> TreeStatement Parser::parseConstDeclaration(TreeBuilder& context)
+{
+    ASSERT(match(CONSTTOKEN));
+    int start = tokenLine();
+    int end = 0;
+    TreeConstDeclList constDecls = parseConstDeclarationList(context);
+    failIfTrue(m_error);
+    failIfFalse(autoSemiColon());
+    
+    return context.createConstStatement(m_lexer->lastLineNumber(), constDecls, start, end);
+}
+
+template <class TreeBuilder> TreeStatement Parser::parseDoWhileStatement(TreeBuilder& context)
+{
+    ASSERT(match(DO));
+    int startLine = tokenLine();
+    next();
+    const Identifier* unused = 0;
+    startLoop();
+    TreeStatement statement = parseStatement(context, unused);
+    endLoop();
+    failIfFalse(statement);
+    int endLine = tokenLine();
+    consumeOrFail(WHILE);
+    consumeOrFail(OPENPAREN);
+    TreeExpression expr = parseExpression(context);
+    failIfFalse(expr);
+    consumeOrFail(CLOSEPAREN);
+    if (match(SEMICOLON))
+        next(); // Always performs automatic semicolon insertion.
+    return context.createDoWhileStatement(m_lexer->lastLineNumber(), statement, expr, startLine, endLine);
+}
+
+template <class TreeBuilder> TreeStatement Parser::parseWhileStatement(TreeBuilder& context)
+{
+    ASSERT(match(WHILE));
+    int startLine = tokenLine();
+    next();
+    consumeOrFail(OPENPAREN);
+    TreeExpression expr = parseExpression(context);
+    failIfFalse(expr);
+    int endLine = tokenLine();
+    consumeOrFail(CLOSEPAREN);
+    const Identifier* unused = 0;
+    startLoop();
+    TreeStatement statement = parseStatement(context, unused);
+    endLoop();
+    failIfFalse(statement);
+    return context.createWhileStatement(m_lexer->lastLineNumber(), expr, statement, startLine, endLine);
+}
+
+template <class TreeBuilder> TreeExpression Parser::parseVarDeclarationList(TreeBuilder& context, int& declarations, const Identifier*& lastIdent, TreeExpression& lastInitializer, int& identStart, int& initStart, int& initEnd)
+{
+    TreeExpression varDecls = 0;
+    do {
+        declarations++;
+        next();
+        matchOrFail(IDENT);
+        
+        int varStart = tokenStart();
+        identStart = varStart;
+        const Identifier* name = m_token.m_data.ident;
+        lastIdent = name;
+        next();
+        bool hasInitializer = match(EQUAL);
+        failIfFalseIfStrictWithNameAndMessage(declareVariable(name), "Cannot declare a variable named", name->impl(), "in strict mode.");
+        context.addVar(name, (hasInitializer || (!m_allowsIn && match(INTOKEN))) ? DeclarationStacks::HasInitializer : 0);
+        if (hasInitializer) {
+            int varDivot = tokenStart() + 1;
+            initStart = tokenStart();
+            next(TreeBuilder::DontBuildStrings); // consume '='
+            int initialAssignments = m_assignmentCount;
+            TreeExpression initializer = parseAssignmentExpression(context);
+            initEnd = lastTokenEnd();
+            lastInitializer = initializer;
+            failIfFalse(initializer);
+            
+            TreeExpression node = context.createAssignResolve(m_lexer->lastLineNumber(), *name, initializer, initialAssignments != m_assignmentCount, varStart, varDivot, lastTokenEnd());
+            if (!varDecls)
+                varDecls = node;
+            else
+                varDecls = context.combineCommaNodes(m_lexer->lastLineNumber(), varDecls, node);
+        }
+    } while (match(COMMA));
+    return varDecls;
+}
+
+template <class TreeBuilder> TreeConstDeclList Parser::parseConstDeclarationList(TreeBuilder& context)
+{
+    failIfTrue(strictMode());
+    TreeConstDeclList constDecls = 0;
+    TreeConstDeclList tail = 0;
+    do {
+        next();
+        matchOrFail(IDENT);
+        const Identifier* name = m_token.m_data.ident;
+        next();
+        bool hasInitializer = match(EQUAL);
+        declareVariable(name);
+        context.addVar(name, DeclarationStacks::IsConstant | (hasInitializer ? DeclarationStacks::HasInitializer : 0));
+        TreeExpression initializer = 0;
+        if (hasInitializer) {
+            next(TreeBuilder::DontBuildStrings); // consume '='
+            initializer = parseAssignmentExpression(context);
+        }
+        tail = context.appendConstDecl(m_lexer->lastLineNumber(), tail, name, initializer);
+        if (!constDecls)
+            constDecls = tail;
+    } while (match(COMMA));
+    return constDecls;
+}
+
+template <class TreeBuilder> TreeStatement Parser::parseForStatement(TreeBuilder& context)
+{
+    ASSERT(match(FOR));
+    int startLine = tokenLine();
+    next();
+    consumeOrFail(OPENPAREN);
+    int nonLHSCount = m_nonLHSCount;
+    int declarations = 0;
+    int declsStart = 0;
+    int declsEnd = 0;
+    TreeExpression decls = 0;
+    bool hasDeclaration = false;
+    if (match(VAR)) {
+        /*
+         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 initStart = 0;
+        int initEnd = 0;
+        decls = parseVarDeclarationList(context, declarations, forInTarget, forInInitializer, declsStart, initStart, initEnd);
+        m_allowsIn = true;
+        if (m_error)
+            fail();
+        
+        // Remainder of a standard for loop is handled identically
+        if (match(SEMICOLON))
+            goto standardForLoop;
+        
+        failIfFalse(declarations == 1);
+        
+        // Handle for-in with var declaration
+        int inLocation = tokenStart();
+        consumeOrFail(INTOKEN);
+        
+        TreeExpression expr = parseExpression(context);
+        failIfFalse(expr);
+        int exprEnd = lastTokenEnd();
+        
+        int endLine = tokenLine();
+        consumeOrFail(CLOSEPAREN);
+        
+        const Identifier* unused = 0;
+        startLoop();
+        TreeStatement statement = parseStatement(context, unused);
+        endLoop();
+        failIfFalse(statement);
+        
+        return context.createForInLoop(m_lexer->lastLineNumber(), forInTarget, forInInitializer, expr, statement, declsStart, inLocation, exprEnd, initStart, initEnd, startLine, endLine);
+    }
+    
+    if (!match(SEMICOLON)) {
+        m_allowsIn = false;
+        declsStart = tokenStart();
+        decls = parseExpression(context);
+        declsEnd = lastTokenEnd();
+        m_allowsIn = true;
+        failIfFalse(decls);
+    }
+    
+    if (match(SEMICOLON)) {
+    standardForLoop:
+        // Standard for loop
+        next();
+        TreeExpression condition = 0;
+        
+        if (!match(SEMICOLON)) {
+            condition = parseExpression(context);
+            failIfFalse(condition);
+        }
+        consumeOrFail(SEMICOLON);
+        
+        TreeExpression increment = 0;
+        if (!match(CLOSEPAREN)) {
+            increment = parseExpression(context);
+            failIfFalse(increment);
+        }
+        int endLine = tokenLine();
+        consumeOrFail(CLOSEPAREN);
+        const Identifier* unused = 0;
+        startLoop();
+        TreeStatement statement = parseStatement(context, unused);
+        endLoop();
+        failIfFalse(statement);
+        return context.createForLoop(m_lexer->lastLineNumber(), decls, condition, increment, statement, hasDeclaration, startLine, endLine);
+    }
+    
+    // For-in loop
+    failIfFalse(nonLHSCount == m_nonLHSCount);
+    consumeOrFail(INTOKEN);
+    TreeExpression expr = parseExpression(context);
+    failIfFalse(expr);
+    int exprEnd = lastTokenEnd();
+    int endLine = tokenLine();
+    consumeOrFail(CLOSEPAREN);
+    const Identifier* unused = 0;
+    startLoop();
+    TreeStatement statement = parseStatement(context, unused);
+    endLoop();
+    failIfFalse(statement);
+    
+    return context.createForInLoop(m_lexer->lastLineNumber(), decls, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine);
+}
+
+template <class TreeBuilder> TreeStatement Parser::parseBreakStatement(TreeBuilder& context)
+{
+    ASSERT(match(BREAK));
+    int startCol = tokenStart();
+    int endCol = tokenEnd();
+    int startLine = tokenLine();
+    int endLine = tokenLine();
+    next();
+    
+    if (autoSemiColon()) {
+        failIfFalseWithMessage(breakIsValid(), "'break' is only valid inside a switch or loop statement");
+        return context.createBreakStatement(m_lexer->lastLineNumber(), startCol, endCol, startLine, endLine);
+    }
+    matchOrFail(IDENT);
+    const Identifier* ident = m_token.m_data.ident;
+    failIfFalseWithNameAndMessage(getLabel(ident), "Label", ident->impl(), "is not defined");
+    endCol = tokenEnd();
+    endLine = tokenLine();
+    next();
+    failIfFalse(autoSemiColon());
+    return context.createBreakStatement(m_lexer->lastLineNumber(), ident, startCol, endCol, startLine, endLine);
+}
+
+template <class TreeBuilder> TreeStatement Parser::parseContinueStatement(TreeBuilder& context)
+{
+    ASSERT(match(CONTINUE));
+    int startCol = tokenStart();
+    int endCol = tokenEnd();
+    int startLine = tokenLine();
+    int endLine = tokenLine();
+    next();
+    
+    if (autoSemiColon()) {
+        failIfFalseWithMessage(continueIsValid(), "'continue' is only valid inside a loop statement");
+        return context.createContinueStatement(m_lexer->lastLineNumber(), startCol, endCol, startLine, endLine);
+    }
+    matchOrFail(IDENT);
+    const Identifier* ident = m_token.m_data.ident;
+    ScopeLabelInfo* label = getLabel(ident);
+    failIfFalseWithNameAndMessage(label, "Label", ident->impl(), "is not defined");
+    failIfFalseWithMessage(label->m_isLoop, "'continue' is only valid inside a loop statement");
+    endCol = tokenEnd();
+    endLine = tokenLine();
+    next();
+    failIfFalse(autoSemiColon());
+    return context.createContinueStatement(m_lexer->lastLineNumber(), ident, startCol, endCol, startLine, endLine);
+}
+
+template <class TreeBuilder> TreeStatement Parser::parseReturnStatement(TreeBuilder& context)
+{
+    ASSERT(match(RETURN));
+    failIfFalse(currentScope()->isFunction());
+    int startLine = tokenLine();
+    int endLine = startLine;
+    int start = tokenStart();
+    int end = tokenEnd();
+    next();
+    // We do the auto semicolon check before attempting to parse an expression
+    // as we need to ensure the a line break after the return correctly terminates
+    // the statement
+    if (match(SEMICOLON))
+        endLine  = tokenLine();
+    if (autoSemiColon())
+        return context.createReturnStatement(m_lexer->lastLineNumber(), 0, start, end, startLine, endLine);
+    TreeExpression expr = parseExpression(context);
+    failIfFalse(expr);
+    end = lastTokenEnd();
+    if (match(SEMICOLON))
+        endLine  = tokenLine();
+    failIfFalse(autoSemiColon());
+    return context.createReturnStatement(m_lexer->lastLineNumber(), expr, start, end, startLine, endLine);
+}
+
+template <class TreeBuilder> TreeStatement Parser::parseThrowStatement(TreeBuilder& context)
+{
+    ASSERT(match(THROW));
+    int eStart = tokenStart();
+    int startLine = tokenLine();
+    next();
+    
+    failIfTrue(autoSemiColon());
+    
+    TreeExpression expr = parseExpression(context);
+    failIfFalse(expr);
+    int eEnd = lastTokenEnd();
+    int endLine = tokenLine();
+    failIfFalse(autoSemiColon());
+    
+    return context.createThrowStatement(m_lexer->lastLineNumber(), expr, eStart, eEnd, startLine, endLine);
+}
+
+template <class TreeBuilder> TreeStatement Parser::parseWithStatement(TreeBuilder& context)
+{
+    ASSERT(match(WITH));
+    failIfTrueWithMessage(strictMode(), "'with' statements are not valid in strict mode");
+    currentScope()->setNeedsFullActivation();
+    int startLine = tokenLine();
+    next();
+    consumeOrFail(OPENPAREN);
+    int start = tokenStart();
+    TreeExpression expr = parseExpression(context);
+    failIfFalse(expr);
+    int end = lastTokenEnd();
+    
+    int endLine = tokenLine();
+    consumeOrFail(CLOSEPAREN);
+    const Identifier* unused = 0;
+    TreeStatement statement = parseStatement(context, unused);
+    failIfFalse(statement);
+    
+    return context.createWithStatement(m_lexer->lastLineNumber(), expr, statement, start, end, startLine, endLine);
+}
+
+template <class TreeBuilder> TreeStatement Parser::parseSwitchStatement(TreeBuilder& context)
+{
+    ASSERT(match(SWITCH));
+    int startLine = tokenLine();
+    next();
+    consumeOrFail(OPENPAREN);
+    TreeExpression expr = parseExpression(context);
+    failIfFalse(expr);
+    int endLine = tokenLine();
+    consumeOrFail(CLOSEPAREN);
+    consumeOrFail(OPENBRACE);
+    startSwitch();
+    TreeClauseList firstClauses = parseSwitchClauses(context);
+    failIfTrue(m_error);
+    
+    TreeClause defaultClause = parseSwitchDefaultClause(context);
+    failIfTrue(m_error);
+    
+    TreeClauseList secondClauses = parseSwitchClauses(context);
+    failIfTrue(m_error);
+    endSwitch();
+    consumeOrFail(CLOSEBRACE);
+    
+    return context.createSwitchStatement(m_lexer->lastLineNumber(), expr, firstClauses, defaultClause, secondClauses, startLine, endLine);
+    
+}
+
+template <class TreeBuilder> TreeClauseList Parser::parseSwitchClauses(TreeBuilder& context)
+{
+    if (!match(CASE))
+        return 0;
+    next();
+    TreeExpression condition = parseExpression(context);
+    failIfFalse(condition);
+    consumeOrFail(COLON);
+    TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);
+    failIfFalse(statements);
+    TreeClause clause = context.createClause(condition, statements);
+    TreeClauseList clauseList = context.createClauseList(clause);
+    TreeClauseList tail = clauseList;
+    
+    while (match(CASE)) {
+        next();
+        TreeExpression condition = parseExpression(context);
+        failIfFalse(condition);
+        consumeOrFail(COLON);
+        TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);
+        failIfFalse(statements);
+        clause = context.createClause(condition, statements);
+        tail = context.createClauseList(tail, clause);
+    }
+    return clauseList;
+}
+
+template <class TreeBuilder> TreeClause Parser::parseSwitchDefaultClause(TreeBuilder& context)
+{
+    if (!match(DEFAULT))
+        return 0;
+    next();
+    consumeOrFail(COLON);
+    TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);
+    failIfFalse(statements);
+    return context.createClause(0, statements);
+}
+
+template <class TreeBuilder> TreeStatement Parser::parseTryStatement(TreeBuilder& context)
+{
+    ASSERT(match(TRY));
+    TreeStatement tryBlock = 0;
+    const Identifier* ident = &m_globalData->propertyNames->nullIdentifier;
+    bool catchHasEval = false;
+    TreeStatement catchBlock = 0;
+    TreeStatement finallyBlock = 0;
+    int firstLine = tokenLine();
+    next();
+    matchOrFail(OPENBRACE);
+    
+    tryBlock = parseBlockStatement(context);
+    failIfFalse(tryBlock);
+    int lastLine = m_lastLine;
+    
+    if (match(CATCH)) {
+        currentScope()->setNeedsFullActivation();
+        next();
+        consumeOrFail(OPENPAREN);
+        matchOrFail(IDENT);
+        ident = m_token.m_data.ident;
+        next();
+        AutoPopScopeRef catchScope(this, pushScope());
+        failIfFalseIfStrictWithNameAndMessage(catchScope->declareVariable(ident), "Cannot declare a variable named", ident->impl(), "in strict mode");
+        catchScope->preventNewDecls();
+        consumeOrFail(CLOSEPAREN);
+        matchOrFail(OPENBRACE);
+        int initialEvalCount = context.evalCount();
+        catchBlock = parseBlockStatement(context);
+        failIfFalseWithMessage(catchBlock, "'try' must have a catch or finally block");
+        catchHasEval = initialEvalCount != context.evalCount();
+        failIfFalse(popScope(catchScope, TreeBuilder::NeedsFreeVariableInfo));
+    }
+    
+    if (match(FINALLY)) {
+        next();
+        matchOrFail(OPENBRACE);
+        finallyBlock = parseBlockStatement(context);
+        failIfFalse(finallyBlock);
+    }
+    failIfFalse(catchBlock || finallyBlock);
+    return context.createTryStatement(m_lexer->lastLineNumber(), tryBlock, ident, catchHasEval, catchBlock, finallyBlock, firstLine, lastLine);
+}
+
+template <class TreeBuilder> TreeStatement Parser::parseDebuggerStatement(TreeBuilder& context)
+{
+    ASSERT(match(DEBUGGER));
+    int startLine = tokenLine();
+    int endLine = startLine;
+    next();
+    if (match(SEMICOLON))
+        startLine = tokenLine();
+    failIfFalse(autoSemiColon());
+    return context.createDebugger(m_lexer->lastLineNumber(), startLine, endLine);
+}
+
+template <class TreeBuilder> TreeStatement Parser::parseBlockStatement(TreeBuilder& context)
+{
+    ASSERT(match(OPENBRACE));
+    int start = tokenLine();
+    next();
+    if (match(CLOSEBRACE)) {
+        next();
+        return context.createBlockStatement(m_lexer->lastLineNumber(), 0, start, m_lastLine);
+    }
+    TreeSourceElements subtree = parseSourceElements<DontCheckForStrictMode>(context);
+    failIfFalse(subtree);
+    matchOrFail(CLOSEBRACE);
+    next();
+    return context.createBlockStatement(m_lexer->lastLineNumber(), subtree, start, m_lastLine);
+}
+
+template <class TreeBuilder> TreeStatement Parser::parseStatement(TreeBuilder& context, const Identifier*& directive)
+{
+    DepthManager statementDepth(&m_statementDepth);
+    m_statementDepth++;
+    directive = 0;
+    int nonTrivialExpressionCount = 0;
+    failIfStackOverflow();
+    switch (m_token.m_type) {
+    case OPENBRACE:
+        return parseBlockStatement(context);
+    case VAR:
+        return parseVarDeclaration(context);
+    case CONSTTOKEN:
+        return parseConstDeclaration(context);
+    case FUNCTION:
+        failIfFalseIfStrictWithMessage(m_statementDepth == 1, "Functions cannot be declared in a nested block in strict mode");
+        return parseFunctionDeclaration(context);
+    case SEMICOLON:
+        next();
+        return context.createEmptyStatement(m_lexer->lastLineNumber());
+    case IF:
+        return parseIfStatement(context);
+    case DO:
+        return parseDoWhileStatement(context);
+    case WHILE:
+        return parseWhileStatement(context);
+    case FOR:
+        return parseForStatement(context);
+    case CONTINUE:
+        return parseContinueStatement(context);
+    case BREAK:
+        return parseBreakStatement(context);
+    case RETURN:
+        return parseReturnStatement(context);
+    case WITH:
+        return parseWithStatement(context);
+    case SWITCH:
+        return parseSwitchStatement(context);
+    case THROW:
+        return parseThrowStatement(context);
+    case TRY:
+        return parseTryStatement(context);
+    case DEBUGGER:
+        return parseDebuggerStatement(context);
+    case EOFTOK:
+    case CASE:
+    case CLOSEBRACE:
+    case DEFAULT:
+        // These tokens imply the end of a set of source elements
+        return 0;
+    case IDENT:
+        return parseExpressionOrLabelStatement(context);
+    case STRING:
+        directive = m_token.m_data.ident;
+        nonTrivialExpressionCount = m_nonTrivialExpressionCount;
+    default:
+        TreeStatement exprStatement = parseExpressionStatement(context);
+        if (directive && nonTrivialExpressionCount != m_nonTrivialExpressionCount)
+            directive = 0;
+        return exprStatement;
+    }
+}
+
+template <class TreeBuilder> TreeFormalParameterList Parser::parseFormalParameters(TreeBuilder& context)
+{
+    matchOrFail(IDENT);
+    failIfFalseIfStrictWithNameAndMessage(declareParameter(m_token.m_data.ident), "Cannot declare a parameter named", m_token.m_data.ident->impl(), " in strict mode");
+    TreeFormalParameterList list = context.createFormalParameterList(*m_token.m_data.ident);
+    TreeFormalParameterList tail = list;
+    next();
+    while (match(COMMA)) {
+        next();
+        matchOrFail(IDENT);
+        const Identifier* ident = m_token.m_data.ident;
+        failIfFalseIfStrictWithNameAndMessage(declareParameter(ident), "Cannot declare a parameter named", ident->impl(), "in strict mode");
+        next();
+        tail = context.createFormalParameterList(tail, *ident);
+    }
+    return list;
+}
+
+template <class TreeBuilder> TreeFunctionBody Parser::parseFunctionBody(TreeBuilder& context)
+{
+    if (match(CLOSEBRACE))
+        return context.createFunctionBody(m_lexer->lastLineNumber(), strictMode());
+    DepthManager statementDepth(&m_statementDepth);
+    m_statementDepth = 0;
+    typename TreeBuilder::FunctionBodyBuilder bodyBuilder(const_cast<JSGlobalData*>(m_globalData), m_lexer);
+    failIfFalse(parseSourceElements<CheckForStrictMode>(bodyBuilder));
+    return context.createFunctionBody(m_lexer->lastLineNumber(), strictMode());
+}
+
+template <Parser::FunctionRequirements requirements, bool nameIsInContainingScope, class TreeBuilder> bool Parser::parseFunctionInfo(TreeBuilder& context, const Identifier*& name, TreeFormalParameterList& parameters, TreeFunctionBody& body, int& openBracePos, int& closeBracePos, int& bodyStartLine)
+{
+    AutoPopScopeRef functionScope(this, pushScope());
+    functionScope->setIsFunction();
+    if (match(IDENT)) {
+        name = m_token.m_data.ident;
+        failIfTrueWithMessage(*name == m_globalData->propertyNames->underscoreProto, "Cannot name a function __proto__");
+        next();
+        if (!nameIsInContainingScope)
+            failIfFalseIfStrict(functionScope->declareVariable(name));
+    } else if (requirements == FunctionNeedsName)
+        return false;
+    consumeOrFail(OPENPAREN);
+    if (!match(CLOSEPAREN)) {
+        parameters = parseFormalParameters(context);
+        failIfFalse(parameters);
+    }
+    consumeOrFail(CLOSEPAREN);
+    matchOrFail(OPENBRACE);
+    
+    openBracePos = m_token.m_data.intValue;
+    bodyStartLine = tokenLine();
+    
+    // If we know about this function already, we can use the cached info and skip the parser to the end of the function.
+    if (const SourceProviderCacheItem* cachedInfo = TreeBuilder::CanUseFunctionCache ? findCachedFunctionInfo(openBracePos) : 0) {
+        // If we're in a strict context, the cached function info must say it was strict too.
+        ASSERT(!strictMode() || cachedInfo->strictMode);
+        body = context.createFunctionBody(m_lexer->lastLineNumber(), cachedInfo->strictMode);
+        
+        functionScope->restoreFunctionInfo(cachedInfo);
+        failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo));
+        
+        closeBracePos = cachedInfo->closeBracePos;
+        m_token = cachedInfo->closeBraceTo