Attachment #155964 for bug #53003

View Details Raw Unified Return to Bug 53003

| Differences between



2012-08-01  Peter Wang  <peter.wang@torchmobile.com.cn>

        Web Inspector: [JSC] implement setting breakpoints by line:column
        https://bugs.webkit.org/show_bug.cgi?id=53003

        Reviewed by Geoffrey Garen.

        Add a counter in lexer to record the column of each token. Debugger will use column info
        in "Pretty Print" debug mode of Inspector.

        * bytecode/Opcode.h:
        (JSC):
        (JSC::padOpcodeName):
        * bytecompiler/BytecodeGenerator.cpp:
        (JSC::BytecodeGenerator::emitDebugHook):
        * bytecompiler/BytecodeGenerator.h:
        (BytecodeGenerator):
        * bytecompiler/NodesCodegen.cpp:
        (JSC::ArrayNode::toArgumentList):
        (JSC::ApplyFunctionCallDotNode::emitBytecode):
        (JSC::ConditionalNode::emitBytecode):
        (JSC::ConstStatementNode::emitBytecode):
        (JSC::EmptyStatementNode::emitBytecode):
        (JSC::DebuggerStatementNode::emitBytecode):
        (JSC::ExprStatementNode::emitBytecode):
        (JSC::VarStatementNode::emitBytecode):
        (JSC::IfNode::emitBytecode):
        (JSC::IfElseNode::emitBytecode):
        (JSC::DoWhileNode::emitBytecode):
        (JSC::WhileNode::emitBytecode):
        (JSC::ForNode::emitBytecode):
        (JSC::ForInNode::emitBytecode):
        (JSC::ContinueNode::emitBytecode):
        (JSC::BreakNode::emitBytecode):
        (JSC::ReturnNode::emitBytecode):
        (JSC::WithNode::emitBytecode):
        (JSC::SwitchNode::emitBytecode):
        (JSC::LabelNode::emitBytecode):
        (JSC::ThrowNode::emitBytecode):
        (JSC::TryNode::emitBytecode):
        (JSC::ProgramNode::emitBytecode):
        (JSC::EvalNode::emitBytecode):
        (JSC::FunctionBodyNode::emitBytecode):
        * debugger/Debugger.h:
        * interpreter/Interpreter.cpp:
        (JSC::Interpreter::unwindCallFrame):
        (JSC::Interpreter::throwException):
        (JSC::Interpreter::debug):
        * interpreter/Interpreter.h:
        (Interpreter):
        * jit/JITOpcodes.cpp:
        (JSC::JIT::emit_op_debug):
        * jit/JITOpcodes32_64.cpp:
        (JSC::JIT::emit_op_debug):
        * jit/JITStubs.cpp:
        (JSC::DEFINE_STUB_FUNCTION):
        * llint/LLIntSlowPaths.cpp:
        (JSC::LLInt::LLINT_SLOW_PATH_DECL):
        * parser/ASTBuilder.h:
        (ASTBuilder):
        (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::createArgumentsList):
        (JSC::ASTBuilder::createPropertyList):
        (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/Lexer.cpp:
        (JSC::::setCode):
        (JSC::::internalShift):
        (JSC::::shift):
        (JSC::::lex):
        * parser/Lexer.h:
        (Lexer):
        (JSC::Lexer::currentColumnNumber):
        (JSC::::lexExpectIdentifier):
        * parser/NodeConstructors.h:
        (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::ArrayNode::ArrayNode):
        (JSC::PropertyListNode::PropertyListNode):
        (JSC::ObjectLiteralNode::ObjectLiteralNode):
        (JSC::BracketAccessorNode::BracketAccessorNode):
        (JSC::DotAccessorNode::DotAccessorNode):
        (JSC::ArgumentListNode::ArgumentListNode):
        (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::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::FuncExprNode::FuncExprNode):
        (JSC::FuncDeclNode::FuncDeclNode):
        (JSC::SwitchNode::SwitchNode):
        (JSC::ConstDeclNode::ConstDeclNode):
        (JSC::BlockNode::BlockNode):
        (JSC::ForInNode::ForInNode):
        * parser/Nodes.cpp:
        (JSC::StatementNode::setLoc):
        (JSC):
        (JSC::ScopeNode::ScopeNode):
        (JSC::ProgramNode::ProgramNode):
        (JSC::ProgramNode::create):
        (JSC::EvalNode::EvalNode):
        (JSC::EvalNode::create):
        (JSC::FunctionBodyNode::FunctionBodyNode):
        (JSC::FunctionBodyNode::create):
        * parser/Nodes.h:
        (Node):
        (JSC::Node::columnNo):
        (ExpressionNode):
        (StatementNode):
        (JSC::StatementNode::column):
        (NullNode):
        (BooleanNode):
        (NumberNode):
        (StringNode):
        (RegExpNode):
        (ThisNode):
        (ResolveNode):
        (ArrayNode):
        (PropertyListNode):
        (ObjectLiteralNode):
        (BracketAccessorNode):
        (DotAccessorNode):
        (ArgumentListNode):
        (NewExprNode):
        (EvalFunctionCallNode):
        (FunctionCallValueNode):
        (FunctionCallResolveNode):
        (FunctionCallBracketNode):
        (FunctionCallDotNode):
        (CallFunctionCallDotNode):
        (ApplyFunctionCallDotNode):
        (PrePostResolveNode):
        (PostfixResolveNode):
        (PostfixBracketNode):
        (PostfixDotNode):
        (PostfixErrorNode):
        (DeleteResolveNode):
        (DeleteBracketNode):
        (DeleteDotNode):
        (DeleteValueNode):
        (VoidNode):
        (TypeOfResolveNode):
        (TypeOfValueNode):
        (PrefixResolveNode):
        (PrefixBracketNode):
        (PrefixDotNode):
        (PrefixErrorNode):
        (UnaryOpNode):
        (UnaryPlusNode):
        (NegateNode):
        (BitwiseNotNode):
        (LogicalNotNode):
        (BinaryOpNode):
        (MultNode):
        (DivNode):
        (ModNode):
        (AddNode):
        (SubNode):
        (LeftShiftNode):
        (RightShiftNode):
        (UnsignedRightShiftNode):
        (LessNode):
        (GreaterNode):
        (LessEqNode):
        (GreaterEqNode):
        (ThrowableBinaryOpNode):
        (InstanceOfNode):
        (InNode):
        (EqualNode):
        (NotEqualNode):
        (StrictEqualNode):
        (NotStrictEqualNode):
        (BitAndNode):
        (BitOrNode):
        (BitXOrNode):
        (LogicalOpNode):
        (ConditionalNode):
        (ReadModifyResolveNode):
        (AssignResolveNode):
        (ReadModifyBracketNode):
        (AssignBracketNode):
        (AssignDotNode):
        (ReadModifyDotNode):
        (AssignErrorNode):
        (CommaNode):
        (ConstDeclNode):
        (ConstStatementNode):
        (BlockNode):
        (EmptyStatementNode):
        (DebuggerStatementNode):
        (ExprStatementNode):
        (VarStatementNode):
        (IfNode):
        (IfElseNode):
        (DoWhileNode):
        (WhileNode):
        (ForNode):
        (ForInNode):
        (ContinueNode):
        (BreakNode):
        (ReturnNode):
        (WithNode):
        (LabelNode):
        (ThrowNode):
        (TryNode):
        (ScopeNode):
        (ProgramNode):
        (EvalNode):
        (FunctionBodyNode):
        (FuncExprNode):
        (FuncDeclNode):
        (SwitchNode):
        * parser/Parser.cpp:
        (JSC::::parseSourceElements):
        (JSC::::parseVarDeclaration):
        (JSC::::parseConstDeclaration):
        (JSC::::parseDoWhileStatement):
        (JSC::::parseWhileStatement):
        (JSC::::parseVarDeclarationList):
        (JSC::::parseConstDeclarationList):
        (JSC::::parseForStatement):
        (JSC::::parseBreakStatement):
        (JSC::::parseContinueStatement):
        (JSC::::parseReturnStatement):
        (JSC::::parseThrowStatement):
        (JSC::::parseWithStatement):
        (JSC::::parseSwitchStatement):
        (JSC::::parseTryStatement):
        (JSC::::parseDebuggerStatement):
        (JSC::::parseBlockStatement):
        (JSC::::parseStatement):
        (JSC::::parseFunctionBody):
        (JSC::::parseFunctionInfo):
        (JSC::::parseFunctionDeclaration):
        (JSC::::parseExpressionOrLabelStatement):
        (JSC::::parseExpressionStatement):
        (JSC::::parseIfStatement):
        (JSC::::parseExpression):
        (JSC::::parseAssignmentExpression):
        (JSC::::parseConditionalExpression):
        (JSC::::parseBinaryExpression):
        (JSC::::parseProperty):
        (JSC::::parseObjectLiteral):
        (JSC::::parseStrictObjectLiteral):
        (JSC::::parseArrayLiteral):
        (JSC::::parsePrimaryExpression):
        (JSC::::parseArguments):
        (JSC::::parseMemberExpression):
        (JSC::::parseUnaryExpression):
        * parser/Parser.h:
        (JSC::Parser::next):
        (JSC::Parser::nextExpectIdentifier):
        (JSC::Parser::tokenStart):
        (JSC::Parser::tokenLine):
        (JSC::Parser::tokenEnd):
        (JSC::Parser::tokenLocation):
        (Parser):
        (JSC::Parser::getTokenName):
        (JSC::::parse):
        * parser/ParserTokens.h:
        (JSC::JSTokenLocation::JSTokenLocation):
        (JSTokenLocation):
        (JSToken):
        * parser/SourceProviderCacheItem.h:
        (JSC::SourceProviderCacheItem::closeBraceToken):
        * parser/SyntaxChecker.h:
        (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::createArgumentsList):
        (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):

2012-08-01  Filip Pizlo  <fpizlo@apple.com>

        DFG should distinguish between PutByVal's that clobber the world and ones that don't



2012-08-01  Peter Wang  <peter.wang@torchmobile.com.cn>

        Web Inspector: [JSC] implement setting breakpoints by line:column
        https://bugs.webkit.org/show_bug.cgi?id=53003

        Reviewed by Geoffrey Garen.

        As JSC is enabled to provide column info of statement, ScriptDebugServer can use it to
        support "Pretty Print" debug mode.

        No new test case for this patch.

        * bindings/js/ScriptDebugServer.cpp:
        (WebCore::ScriptDebugServer::setBreakpoint):
        (WebCore::ScriptDebugServer::removeBreakpoint):
        (WebCore):
        (WebCore::ScriptDebugServer::updateCurrentStatementPosition):
        (WebCore::ScriptDebugServer::hasBreakpoint):
        (WebCore::ScriptDebugServer::createCallFrameAndPauseIfNeeded):
        (WebCore::ScriptDebugServer::updateCallFrameAndPauseIfNeeded):
        (WebCore::ScriptDebugServer::callEvent):
        (WebCore::ScriptDebugServer::atStatement):
        (WebCore::ScriptDebugServer::returnEvent):
        (WebCore::ScriptDebugServer::exception):
        (WebCore::ScriptDebugServer::willExecuteProgram):
        (WebCore::ScriptDebugServer::didExecuteProgram):
        (WebCore::ScriptDebugServer::didReachBreakpoint):
        * bindings/js/ScriptDebugServer.h:
        (ScriptDebugServer):

2012-08-01  Xingnan Wang  <xingnan.wang@intel.com>

        IndexedDB: ObjectStoreMetaDataKey::m_metaDataType should use byte type

Lines 194-200 namespace JSC { a/Source/JavaScriptCore/bytecode/Opcode.h_sec1
- a/Source/JavaScriptCore/bytecode/Opcode.h -1 / +1 lines
194	macro(op_throw, 2) \	194	macro(op_throw, 2) \
195	macro(op_throw_reference_error, 2) \	195	macro(op_throw_reference_error, 2) \
196	\	196	\
197	macro(op_debug, 4) \	197	macro(op_debug, 5) \
198	macro(op_profile_will_call, 2) \	198	macro(op_profile_will_call, 2) \
199	macro(op_profile_did_call, 2) \	199	macro(op_profile_did_call, 2) \
200	\	200	\



    m_dynamicScopeDepth--;
}

void BytecodeGenerator::emitDebugHook(DebugHookID debugHookID, int firstLine, int lastLine, int column)
{
#if ENABLE(DEBUG_WITH_BREAKPOINT)
    if (debugHookID != DidReachBreakpoint)

    instructions().append(debugHookID);
    instructions().append(firstLine);
    instructions().append(lastLine);
    instructions().append(column);
}

void BytecodeGenerator::pushFinallyContext(StatementNode* finallyBlock)

Lines 506-512 namespace JSC { a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h_sec1
- a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h -1 / +1 lines
506	RegisterID* emitPushScope(RegisterID* scope);	506	RegisterID* emitPushScope(RegisterID* scope);
507	void emitPopScope();	507	void emitPopScope();
508		508
509	void emitDebugHook(DebugHookID, int firstLine, int lastLine);	509	void emitDebugHook(DebugHookID, int firstLine, int lastLine, int column);
510		510
511	int scopeDepth() { return m_dynamicScopeDepth + m_finallyDepth; }	511	int scopeDepth() { return m_dynamicScopeDepth + m_finallyDepth; }
512	bool hasFinaliser() { return m_finallyDepth != 0; }	512	bool hasFinaliser() { return m_finallyDepth != 0; }



    return true;
}

ArgumentListNode* ArrayNode::toArgumentList(JSGlobalData* globalData, int lineNumber, int columnNumber) const
{
    ASSERT(!m_elision && !m_optional);
    ElementNode* ptr = m_element;
    if (!ptr)
        return 0;
    JSTokenLocation location;
    location.line = lineNumber;
    location.column = columnNumber;
    ArgumentListNode* head = new (globalData) ArgumentListNode(location, ptr->value());
    ArgumentListNode* tail = head;
    ptr = ptr->next();
    for (; ptr; ptr = ptr->next()) {
        ASSERT(!ptr->elision());
        tail = new (globalData) ArgumentListNode(location, tail, ptr->value());
    }
    return head;
}

                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(), 0, 0);
                    RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
                    CallArguments callArguments(generator, m_args);
                    generator.emitNode(callArguments.thisRegister(), oldList->m_expr);

    RefPtr<Label> beforeElse = generator.newLabel();
    RefPtr<Label> afterElse = generator.newLabel();

    generator.emitDebugHook(WillExecuteStatement, lineNo(), lineNo(), columnNo());

    if (m_logical->hasConditionContextCodegen()) {
        RefPtr<Label> beforeThen = generator.newLabel();
        generator.emitNodeInConditionContext(m_logical, beforeThen.get(), beforeElse.get(), true);


RegisterID* ConstStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
{
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    return generator.emitNode(m_next);
}



RegisterID* EmptyStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    return dst;
}



RegisterID* DebuggerStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
    generator.emitDebugHook(DidReachBreakpoint, firstLine(), lastLine(), column());
    return dst;
}


RegisterID* ExprStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
    ASSERT(m_expr);
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    return generator.emitNode(dst, m_expr);
}


RegisterID* VarStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
{
    ASSERT(m_expr);
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    return generator.emitNode(m_expr);
}



RegisterID* IfNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    
    RefPtr<Label> afterThen = generator.newLabel();



RegisterID* IfElseNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    
    RefPtr<Label> beforeElse = generator.newLabel();
    RefPtr<Label> afterElse = generator.newLabel();

    RefPtr<Label> topOfLoop = generator.newLabel();
    generator.emitLabel(topOfLoop.get());
    generator.emitLoopHint();
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine());
   
    RefPtr<RegisterID> result = generator.emitNode(dst, m_statement);

    generator.emitLabel(scope->continueTarget());
    generator.emitDebugHook(WillExecuteStatement, lastLine(), lastLine(), column());
    if (m_expr->hasConditionContextCodegen())
        generator.emitNodeInConditionContext(m_expr, topOfLoop.get(), scope->breakTarget(), false);
    else {

    RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Loop);
    RefPtr<Label> topOfLoop = generator.newLabel();

    generator.emitDebugHook(WillExecuteStatement, m_expr->lineNo(), m_expr->lineNo(), m_expr->columnNo());
    if (m_expr->hasConditionContextCodegen())
        generator.emitNodeInConditionContext(m_expr, topOfLoop.get(), scope->breakTarget(), true);
    else {

    generator.emitNode(dst, m_statement);

    generator.emitLabel(scope->continueTarget());
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());

    if (m_expr->hasConditionContextCodegen())
        generator.emitNodeInConditionContext(m_expr, topOfLoop.get(), scope->breakTarget(), false);

{
    RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Loop);

    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());

    if (m_expr1)
        generator.emitNode(generator.ignoredResult(), m_expr1);

    RefPtr<RegisterID> result = generator.emitNode(dst, m_statement);

    generator.emitLabel(scope->continueTarget());
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    if (m_expr3)
        generator.emitNode(generator.ignoredResult(), m_expr3);


    if (!m_lexpr->isLocation())
        return emitThrowReferenceError(generator, "Left side of for-in statement is not a reference.");

    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());

    if (m_init)
        generator.emitNode(generator.ignoredResult(), m_init);


    generator.emitLabel(scope->continueTarget());
    generator.emitNextPropertyName(propertyName, base.get(), i.get(), size.get(), iter.get(), loopStart.get());
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    generator.emitLabel(scope->breakTarget());
    return dst;
}

// ECMA 12.7
RegisterID* ContinueNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    
    LabelScope* scope = generator.continueTarget(m_ident);
    ASSERT(scope);

// ECMA 12.8
RegisterID* BreakNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    
    LabelScope* scope = generator.breakTarget(m_ident);
    ASSERT(scope);


RegisterID* ReturnNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    ASSERT(generator.codeType() == FunctionCode);

    if (dst == generator.ignoredResult())

        generator.emitJumpScopes(l0.get(), 0);
        generator.emitLabel(l0.get());
    }
    generator.emitDebugHook(WillLeaveCallFrame, firstLine(), lastLine(), column());
    return generator.emitReturn(r0);
}



RegisterID* WithNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    
    RefPtr<RegisterID> scope = generator.newTemporary();
    generator.emitNode(scope.get(), m_expr); // scope must be protected until popped


RegisterID* SwitchNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());
    
    RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Switch);



RegisterID* LabelNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());

    ASSERT(!generator.breakTarget(m_name));



RegisterID* ThrowNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());

    if (dst == generator.ignoredResult())
        dst = 0;

    // NOTE: The catch and finally blocks must be labeled explicitly, so the
    // optimizer knows they may be jumped to from anywhere.

    generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), column());

    RefPtr<Label> tryStartLabel = generator.newLabel();
    if (m_finallyBlock)


RegisterID* ProgramNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
{
    generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine(), column());

    RefPtr<RegisterID> dstRegister = generator.newTemporary();
    generator.emitLoad(dstRegister.get(), jsUndefined());
    emitStatementsBytecode(generator, dstRegister.get());

    generator.emitDebugHook(DidExecuteProgram, firstLine(), lastLine(), column());
    generator.emitEnd(dstRegister.get());
    return 0;
}


RegisterID* EvalNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
{
    generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine(), column());

    RefPtr<RegisterID> dstRegister = generator.newTemporary();
    generator.emitLoad(dstRegister.get(), jsUndefined());
    emitStatementsBytecode(generator, dstRegister.get());

    generator.emitDebugHook(DidExecuteProgram, firstLine(), lastLine(), column());
    generator.emitEnd(dstRegister.get());
    return 0;
}


RegisterID* FunctionBodyNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
{
    generator.emitDebugHook(DidEnterCallFrame, firstLine(), lastLine(), column());
    emitStatementsBytecode(generator, generator.ignoredResult());

    StatementNode* singleStatement = this->singleStatement();

    // If there is no return we must automatically insert one.
    if (!returnNode) {
        RegisterID* r0 = generator.isConstructor() ? generator.thisRegister() : generator.emitLoad(0, jsUndefined());
        generator.emitDebugHook(WillLeaveCallFrame, firstLine(), lastLine(), column());
        generator.emitReturn(r0);
        return 0;
    }



        virtual void detach(JSGlobalObject*);

        virtual void sourceParsed(ExecState*, SourceProvider*, int errorLineNumber, const UString& errorMessage) = 0;
        virtual void exception(const DebuggerCallFrame&, intptr_t, int, bool) = 0;
        virtual void atStatement(const DebuggerCallFrame&, intptr_t, int) = 0;
        virtual void callEvent(const DebuggerCallFrame&, intptr_t, int) = 0;
        virtual void returnEvent(const DebuggerCallFrame&, intptr_t, int) = 0;

        virtual void exception(const DebuggerCallFrame&, intptr_t, int, int, bool) { };
        virtual void atStatement(const DebuggerCallFrame&, intptr_t, int, int) { };
        virtual void callEvent(const DebuggerCallFrame&, intptr_t, int, int) { };
        virtual void returnEvent(const DebuggerCallFrame&, intptr_t, int, int) { };


        virtual void willExecuteProgram(const DebuggerCallFrame&, intptr_t, int) = 0;
        virtual void didExecuteProgram(const DebuggerCallFrame&, intptr_t, int) = 0;
        virtual void didReachBreakpoint(const DebuggerCallFrame&, intptr_t, int) = 0;

        virtual void willExecuteProgram(const DebuggerCallFrame&, intptr_t, int, int) { };
        virtual void didExecuteProgram(const DebuggerCallFrame&, intptr_t, int, int) { };
        virtual void didReachBreakpoint(const DebuggerCallFrame&, intptr_t, int, int) { };


        void recompileAllJSFunctions(JSGlobalData*);




    if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {
        DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);
        if (callFrame->callee())
            debugger->returnEvent(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->lastLine(), 0);
        else
            debugger->didExecuteProgram(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->lastLine(), 0);
    }

    // If this call frame created an activation or an 'arguments' object, tear it off.

    if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {
        DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);
        bool hasHandler = codeBlock->handlerForBytecodeOffset(bytecodeOffset);
        debugger->exception(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->lineNumberForBytecodeOffset(bytecodeOffset), 0, hasHandler);
    }

    // Calculate an exception handler vPC, unwinding call frames as necessary.

    return checkedReturn(result);
}

NEVER_INLINE void Interpreter::debug(CallFrame* callFrame, DebugHookID debugHookID, int firstLine, int lastLine, int column)
{
    Debugger* debugger = callFrame->dynamicGlobalObject()->debugger();
    if (!debugger)


    switch (debugHookID) {
        case DidEnterCallFrame:
            debugger->callEvent(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine, column);
            return;
        case WillLeaveCallFrame:
            debugger->returnEvent(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine, column);
            return;
        case WillExecuteStatement:
            debugger->atStatement(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine, column);
            return;
        case WillExecuteProgram:
            debugger->willExecuteProgram(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine, column);
            return;
        case DidExecuteProgram:
            debugger->didExecuteProgram(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine, column);
            return;
        case DidReachBreakpoint:
            debugger->didReachBreakpoint(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine, column);
            return;
    }
}

Lines 240-246 namespace JSC { a/Source/JavaScriptCore/interpreter/Interpreter.h_sec1
- a/Source/JavaScriptCore/interpreter/Interpreter.h -1 / +1 lines
240	SamplingTool* sampler() { return m_sampler.get(); }	240	SamplingTool* sampler() { return m_sampler.get(); }
241		241
242	NEVER_INLINE HandlerInfo* throwException(CallFrame*&, JSValue&, unsigned bytecodeOffset);	242	NEVER_INLINE HandlerInfo* throwException(CallFrame*&, JSValue&, unsigned bytecodeOffset);
243	NEVER_INLINE void debug(CallFrame*, DebugHookID, int firstLine, int lastLine);	243	NEVER_INLINE void debug(CallFrame*, DebugHookID, int firstLine, int lastLine, int column);
244	static const UString getTraceLine(CallFrame*, StackFrameCodeType, const UString&, int);	244	static const UString getTraceLine(CallFrame*, StackFrameCodeType, const UString&, int);
245	JS_EXPORT_PRIVATE static void getStackTrace(JSGlobalData*, Vector<StackFrame>& results);	245	JS_EXPORT_PRIVATE static void getStackTrace(JSGlobalData*, Vector<StackFrame>& results);
246	static void addStackTraceIfNecessary(CallFrame, JSObject error);	246	static void addStackTraceIfNecessary(CallFrame, JSObject error);

Lines 1158-1163 void JIT::emit_op_debug(Instruction* currentInstruction) a/Source/JavaScriptCore/jit/JITOpcodes.cpp_sec1
- a/Source/JavaScriptCore/jit/JITOpcodes.cpp +1 lines
1158	stubCall.addArgument(TrustedImm32(currentInstruction[1].u.operand));	1158	stubCall.addArgument(TrustedImm32(currentInstruction[1].u.operand));
1159	stubCall.addArgument(TrustedImm32(currentInstruction[2].u.operand));	1159	stubCall.addArgument(TrustedImm32(currentInstruction[2].u.operand));
1160	stubCall.addArgument(TrustedImm32(currentInstruction[3].u.operand));	1160	stubCall.addArgument(TrustedImm32(currentInstruction[3].u.operand));
		1161	stubCall.addArgument(TrustedImm32(currentInstruction[4].u.operand));
1161	stubCall.call();	1162	stubCall.call();
1162	#endif	1163	#endif
1163	}	1164	}

Lines 1478-1483 void JIT::emit_op_debug(Instruction* currentInstruction) a/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp_sec1
- a/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp +1 lines
1478	stubCall.addArgument(Imm32(currentInstruction[1].u.operand));	1478	stubCall.addArgument(Imm32(currentInstruction[1].u.operand));
1479	stubCall.addArgument(Imm32(currentInstruction[2].u.operand));	1479	stubCall.addArgument(Imm32(currentInstruction[2].u.operand));
1480	stubCall.addArgument(Imm32(currentInstruction[3].u.operand));	1480	stubCall.addArgument(Imm32(currentInstruction[3].u.operand));
		1481	stubCall.addArgument(Imm32(currentInstruction[4].u.operand));
1481	stubCall.call();	1482	stubCall.call();
1482	#endif	1483	#endif
1483	}	1484	}



    int debugHookID = stackFrame.args[0].int32();
    int firstLine = stackFrame.args[1].int32();
    int lastLine = stackFrame.args[2].int32();
    int column = stackFrame.args[3].int32();

    stackFrame.globalData->interpreter->debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine, column);
}

DEFINE_STUB_FUNCTION(void*, vm_throw)



    int debugHookID = pc[1].u.operand;
    int firstLine = pc[2].u.operand;
    int lastLine = pc[3].u.operand;
    int column = pc[4].u.operand;

    globalData.interpreter->debug(exec, static_cast<DebugHookID>(debugHookID), firstLine, lastLine, column);
    
    LLINT_END();
}



    static const int  DontBuildKeywords = 0;
    static const int  DontBuildStrings = 0;

    ExpressionNode* makeBinaryNode(const JSTokenLocation&, int token, std::pair<ExpressionNode*, BinaryOpInfo>, std::pair<ExpressionNode*, BinaryOpInfo>);
    ExpressionNode* makeFunctionCallNode(const JSTokenLocation&, ExpressionNode* func, ArgumentsNode* args, int start, int divot, int end);

    JSC::SourceElements* createSourceElements() { return new (m_globalData) JSC::SourceElements(); }



    void appendToComma(CommaNode* commaNode, ExpressionNode* expr) { commaNode->append(expr); }

    CommaNode* createCommaExpr(const JSTokenLocation& location, ExpressionNode* lhs, ExpressionNode* rhs) { return new (m_globalData) CommaNode(location, lhs, rhs); }

    ExpressionNode* makeAssignNode(const JSTokenLocation&, ExpressionNode* left, Operator, ExpressionNode* right, bool leftHasAssignments, bool rightHasAssignments, int start, int divot, int end);
    ExpressionNode* makePrefixNode(const JSTokenLocation&, ExpressionNode*, Operator, int start, int divot, int end);
    ExpressionNode* makePostfixNode(const JSTokenLocation&, ExpressionNode*, Operator, int start, int divot, int end);
    ExpressionNode* makeTypeOfNode(const JSTokenLocation&, ExpressionNode*);
    ExpressionNode* makeDeleteNode(const JSTokenLocation&, ExpressionNode*, int start, int divot, int end);
    ExpressionNode* makeNegateNode(const JSTokenLocation&, ExpressionNode*);
    ExpressionNode* makeBitwiseNotNode(const JSTokenLocation&, ExpressionNode*);
    ExpressionNode* makeMultNode(const JSTokenLocation&, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    ExpressionNode* makeDivNode(const JSTokenLocation&, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    ExpressionNode* makeModNode(const JSTokenLocation&, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    ExpressionNode* makeAddNode(const JSTokenLocation&, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    ExpressionNode* makeSubNode(const JSTokenLocation&, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    ExpressionNode* makeBitXOrNode(const JSTokenLocation&, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    ExpressionNode* makeBitAndNode(const JSTokenLocation&, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    ExpressionNode* makeBitOrNode(const JSTokenLocation&, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    ExpressionNode* makeLeftShiftNode(const JSTokenLocation&, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    ExpressionNode* makeRightShiftNode(const JSTokenLocation&, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    ExpressionNode* makeURightShiftNode(const JSTokenLocation&, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);

    ExpressionNode* createLogicalNot(const JSTokenLocation& location, ExpressionNode* expr) { return new (m_globalData) LogicalNotNode(location, expr); }
    ExpressionNode* createUnaryPlus(const JSTokenLocation& location, ExpressionNode* expr) { return new (m_globalData) UnaryPlusNode(location, expr); }
    ExpressionNode* createVoid(const JSTokenLocation& location, ExpressionNode* expr)
    {
        incConstants();
        return new (m_globalData) VoidNode(location, expr);
    }
    ExpressionNode* thisExpr(const JSTokenLocation& location)
    {
        usesThis();
        return new (m_globalData) ThisNode(location);
    }
    ExpressionNode* createResolve(const JSTokenLocation& location, const Identifier* ident, int start)
    {
        if (m_globalData->propertyNames->arguments == *ident)
            usesArguments();
        return new (m_globalData) ResolveNode(location, *ident, start);
    }
    ExpressionNode* createObjectLiteral(const JSTokenLocation& location) { return new (m_globalData) ObjectLiteralNode(location); }
    ExpressionNode* createObjectLiteral(const JSTokenLocation& location, PropertyListNode* properties) { return new (m_globalData) ObjectLiteralNode(location, properties); }

    ExpressionNode* createArray(const JSTokenLocation& location, int elisions)
    {
        if (elisions)
            incConstants();
        return new (m_globalData) ArrayNode(location, elisions);
    }

    ExpressionNode* createArray(const JSTokenLocation& location, ElementNode* elems) { return new (m_globalData) ArrayNode(location, elems); }
    ExpressionNode* createArray(const JSTokenLocation& location, int elisions, ElementNode* elems)
    {
        if (elisions)
            incConstants();
        return new (m_globalData) ArrayNode(location, elisions, elems);
    }
    ExpressionNode* createNumberExpr(const JSTokenLocation& location, double d)
    {
        incConstants();
        return new (m_globalData) NumberNode(location, d);
    }

    ExpressionNode* createString(const JSTokenLocation& location, const Identifier* string)
    {
        incConstants();
        return new (m_globalData) StringNode(location, *string);
    }

    ExpressionNode* createBoolean(const JSTokenLocation& location, bool b)
    {
        incConstants();
        return new (m_globalData) BooleanNode(location, b);
    }

    ExpressionNode* createNull(const JSTokenLocation& location)
    {
        incConstants();
        return new (m_globalData) NullNode(location);
    }

    ExpressionNode* createBracketAccess(const JSTokenLocation& location, ExpressionNode* base, ExpressionNode* property, bool propertyHasAssignments, int start, int divot, int end)
    {
        BracketAccessorNode* node = new (m_globalData) BracketAccessorNode(location, base, property, propertyHasAssignments);
        setExceptionLocation(node, start, divot, end);
        return node;
    }

    ExpressionNode* createDotAccess(const JSTokenLocation& location, ExpressionNode* base, const Identifier* property, int start, int divot, int end)
    {
        DotAccessorNode* node = new (m_globalData) DotAccessorNode(location, base, *property);
        setExceptionLocation(node, start, divot, end);
        return node;
    }

    ExpressionNode* createRegExp(const JSTokenLocation& location, const Identifier& pattern, const Identifier& flags, int start)
    {
        if (Yarr::checkSyntax(pattern.ustring()))
            return 0;
        RegExpNode* node = new (m_globalData) RegExpNode(location, pattern, flags);
        int size = pattern.length() + 2; // + 2 for the two /'s
        setExceptionLocation(node, start, start + size, start + size);
        return node;
    }

    ExpressionNode* createNewExpr(const JSTokenLocation& location, ExpressionNode* expr, ArgumentsNode* arguments, int start, int divot, int end)
    {
        NewExprNode* node = new (m_globalData) NewExprNode(location, expr, arguments);
        setExceptionLocation(node, start, divot, end);
        return node;
    }

    ExpressionNode* createNewExpr(const JSTokenLocation& location, ExpressionNode* expr, int start, int end)
    {
        NewExprNode* node = new (m_globalData) NewExprNode(location, expr);
        setExceptionLocation(node, start, end, end);
        return node;
    }

    ExpressionNode* createConditionalExpr(const JSTokenLocation& location, ExpressionNode* condition, ExpressionNode* lhs, ExpressionNode* rhs)
    {
        return new (m_globalData) ConditionalNode(location, condition, lhs, rhs);
    }

    ExpressionNode* createAssignResolve(const JSTokenLocation& location, const Identifier& ident, ExpressionNode* rhs, int start, int divot, int end)
    {
        if (rhs->isFuncExprNode())
            static_cast<FuncExprNode*>(rhs)->body()->setInferredName(ident);
        AssignResolveNode* node = new (m_globalData) AssignResolveNode(location, ident, rhs);
        setExceptionLocation(node, start, divot, end);
        return node;
    }

    ExpressionNode* createFunctionExpr(const JSTokenLocation& location, const Identifier* name, FunctionBodyNode* body, ParameterNode* parameters, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
    {
        FuncExprNode* result = new (m_globalData) FuncExprNode(location, *name, body, m_sourceCode->subExpression(openBracePos, closeBracePos, bodyStartLine), parameters);
        body->setLoc(bodyStartLine, bodyEndLine, location.column);
        return result;
    }

    FunctionBodyNode* createFunctionBody(const JSTokenLocation& location, bool inStrictContext)
    {
        return FunctionBodyNode::create(m_globalData, location, inStrictContext);
    }
    
    template <bool> PropertyNode* createGetterOrSetterProperty(const JSTokenLocation& location, PropertyNode::Type type, const Identifier* name, ParameterNode* params, FunctionBodyNode* body, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
    {
        ASSERT(name);
        body->setLoc(bodyStartLine, bodyEndLine, location.column);
        body->setInferredName(*name);
        return new (m_globalData) PropertyNode(m_globalData, *name, new (m_globalData) FuncExprNode(location, m_globalData->propertyNames->nullIdentifier, body, m_sourceCode->subExpression(openBracePos, closeBracePos, bodyStartLine), params), type);
    }
    
    template <bool> PropertyNode* createGetterOrSetterProperty(JSGlobalData*, const JSTokenLocation& location, PropertyNode::Type type, double name, ParameterNode* params, FunctionBodyNode* body, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
    {
        body->setLoc(bodyStartLine, bodyEndLine, location.column);
        return new (m_globalData) PropertyNode(m_globalData, name, new (m_globalData) FuncExprNode(location, m_globalData->propertyNames->nullIdentifier, body, m_sourceCode->subExpression(openBracePos, closeBracePos, bodyStartLine), params), type);
    }

    ArgumentsNode* createArguments() { return new (m_globalData) ArgumentsNode(); }
    ArgumentsNode* createArguments(ArgumentListNode* args) { return new (m_globalData) ArgumentsNode(args); }
    ArgumentListNode* createArgumentsList(const JSTokenLocation& location, ExpressionNode* arg) { return new (m_globalData) ArgumentListNode(location, arg); }
    ArgumentListNode* createArgumentsList(const JSTokenLocation& location, ArgumentListNode* args, ExpressionNode* arg) { return new (m_globalData) ArgumentListNode(location, 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(const JSTokenLocation& location, PropertyNode* property) { return new (m_globalData) PropertyListNode(location, property); }
    PropertyListNode* createPropertyList(const JSTokenLocation& location, PropertyNode* property, PropertyListNode* tail) { return new (m_globalData) PropertyListNode(location, property, tail); }

    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); }


    void setUsesArguments(FunctionBodyNode* node) { node->setUsesArguments(); }

    StatementNode* createFuncDeclStatement(const JSTokenLocation& location, const Identifier* name, FunctionBodyNode* body, ParameterNode* parameters, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
    {
        FuncDeclNode* decl = new (m_globalData) FuncDeclNode(location, *name, body, m_sourceCode->subExpression(openBracePos, closeBracePos, bodyStartLine), parameters);
        if (*name == m_globalData->propertyNames->arguments)
            usesArguments();
        m_scope.m_funcDeclarations->data.append(decl->body());
        body->setLoc(bodyStartLine, bodyEndLine, location.column);
        return decl;
    }

    StatementNode* createBlockStatement(const JSTokenLocation& location, JSC::SourceElements* elements, int startLine, int endLine)
    {
        BlockNode* block = new (m_globalData) BlockNode(location, elements);
        block->setLoc(startLine, endLine, location.column);
        return block;
    }

    StatementNode* createExprStatement(const JSTokenLocation& location, ExpressionNode* expr, int start, int end)
    {
        ExprStatementNode* result = new (m_globalData) ExprStatementNode(location, expr);
        result->setLoc(start, end, location.column);
        return result;
    }

    StatementNode* createIfStatement(const JSTokenLocation& location, ExpressionNode* condition, StatementNode* trueBlock, int start, int end)
    {
        IfNode* result = new (m_globalData) IfNode(location, condition, trueBlock);
        result->setLoc(start, end, location.column);
        return result;
    }

    StatementNode* createIfStatement(const JSTokenLocation& location, ExpressionNode* condition, StatementNode* trueBlock, StatementNode* falseBlock, int start, int end)
    {
        IfNode* result = new (m_globalData) IfElseNode(location, condition, trueBlock, falseBlock);
        result->setLoc(start, end, location.column);
        return result;
    }

    StatementNode* createForLoop(const JSTokenLocation& location, ExpressionNode* initializer, ExpressionNode* condition, ExpressionNode* iter, StatementNode* statements, int start, int end)
    {
        ForNode* result = new (m_globalData) ForNode(location, initializer, condition, iter, statements);
        result->setLoc(start, end);
        return result;
    }

    StatementNode* createForInLoop(const JSTokenLocation& location, 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, location, *ident, initializer, iter, statements, initStart, initStart - start, initEnd - initStart);
        result->setLoc(startLine, endLine, location.column);
        setExceptionLocation(result, start, divot + 1, end);
        return result;
    }

    StatementNode* createForInLoop(const JSTokenLocation& location, ExpressionNode* lhs, ExpressionNode* iter, StatementNode* statements, int eStart, int eDivot, int eEnd, int start, int end)
    {
        ForInNode* result = new (m_globalData) ForInNode(location, lhs, iter, statements);
        result->setLoc(start, end, location.column);
        setExceptionLocation(result, eStart, eDivot, eEnd);
        return result;
    }

    StatementNode* createEmptyStatement(const JSTokenLocation& location) { return new (m_globalData) EmptyStatementNode(location); }

    StatementNode* createVarStatement(const JSTokenLocation& location, ExpressionNode* expr, int start, int end)
    {
        StatementNode* result;
        if (!expr)
            result = new (m_globalData) EmptyStatementNode(location);
        else
            result = new (m_globalData) VarStatementNode(location, expr);
        result->setLoc(start, end, location.column);
        return result;
    }

    StatementNode* createReturnStatement(const JSTokenLocation& location, ExpressionNode* expression, int eStart, int eEnd, int startLine, int endLine)
    {
        ReturnNode* result = new (m_globalData) ReturnNode(location, expression);
        setExceptionLocation(result, eStart, eEnd, eEnd);
        result->setLoc(startLine, endLine, location.column);
        return result;
    }

    StatementNode* createBreakStatement(const JSTokenLocation& location, int eStart, int eEnd, int startLine, int endLine)
    {
        BreakNode* result = new (m_globalData) BreakNode(m_globalData, location);
        setExceptionLocation(result, eStart, eEnd, eEnd);
        result->setLoc(startLine, endLine, location.column);
        return result;
    }

    StatementNode* createBreakStatement(const JSTokenLocation& location, const Identifier* ident, int eStart, int eEnd, int startLine, int endLine)
    {
        BreakNode* result = new (m_globalData) BreakNode(location, *ident);
        setExceptionLocation(result, eStart, eEnd, eEnd);
        result->setLoc(startLine, endLine, location.column);
        return result;
    }

    StatementNode* createContinueStatement(const JSTokenLocation& location, int eStart, int eEnd, int startLine, int endLine)
    {
        ContinueNode* result = new (m_globalData) ContinueNode(m_globalData, location);
        setExceptionLocation(result, eStart, eEnd, eEnd);
        result->setLoc(startLine, endLine, location.column);
        return result;
    }

    StatementNode* createContinueStatement(const JSTokenLocation& location, const Identifier* ident, int eStart, int eEnd, int startLine, int endLine)
    {
        ContinueNode* result = new (m_globalData) ContinueNode(location, *ident);
        setExceptionLocation(result, eStart, eEnd, eEnd);
        result->setLoc(startLine, endLine, location.column);
        return result;
    }

    StatementNode* createTryStatement(const JSTokenLocation& location, StatementNode* tryBlock, const Identifier* ident, StatementNode* catchBlock, StatementNode* finallyBlock, int startLine, int endLine)
    {
        TryNode* result = new (m_globalData) TryNode(location, tryBlock, *ident, catchBlock, finallyBlock);
        if (catchBlock)
            usesCatch();
        result->setLoc(startLine, endLine, location.column);
        return result;
    }

    StatementNode* createSwitchStatement(const JSTokenLocation& location, ExpressionNode* expr, ClauseListNode* firstClauses, CaseClauseNode* defaultClause, ClauseListNode* secondClauses, int startLine, int endLine)
    {
        CaseBlockNode* cases = new (m_globalData) CaseBlockNode(firstClauses, defaultClause, secondClauses);
        SwitchNode* result = new (m_globalData) SwitchNode(location, expr, cases);
        result->setLoc(startLine, endLine, location.column);
        return result;
    }

    StatementNode* createWhileStatement(const JSTokenLocation& location, ExpressionNode* expr, StatementNode* statement, int startLine, int endLine)
    {
        WhileNode* result = new (m_globalData) WhileNode(location, expr, statement);
        result->setLoc(startLine, endLine, location.column);
        return result;
    }

    StatementNode* createDoWhileStatement(const JSTokenLocation& location, StatementNode* statement, ExpressionNode* expr, int startLine, int endLine)
    {
        DoWhileNode* result = new (m_globalData) DoWhileNode(location, statement, expr);
        result->setLoc(startLine, endLine, location.column);
        return result;
    }

    StatementNode* createLabelStatement(const JSTokenLocation& location, const Identifier* ident, StatementNode* statement, int start, int end)
    {
        LabelNode* result = new (m_globalData) LabelNode(location, *ident, statement);
        setExceptionLocation(result, start, end, end);
        return result;
    }

    StatementNode* createWithStatement(const JSTokenLocation& location, ExpressionNode* expr, StatementNode* statement, int start, int end, int startLine, int endLine)
    {
        usesWith();
        WithNode* result = new (m_globalData) WithNode(location, expr, statement, end, end - start);
        result->setLoc(startLine, endLine, location.column);
        return result;
    }    
    
    StatementNode* createThrowStatement(const JSTokenLocation& location, ExpressionNode* expr, int start, int end, int startLine, int endLine)
    {
        ThrowNode* result = new (m_globalData) ThrowNode(location, expr);
        result->setLoc(startLine, endLine, location.column);
        setExceptionLocation(result, start, end, end);
        return result;
    }
    
    StatementNode* createDebugger(const JSTokenLocation& location, int startLine, int endLine)
    {
        DebuggerStatementNode* result = new (m_globalData) DebuggerStatementNode(location);
        result->setLoc(startLine, endLine, location.column);
        return result;
    }
    
    StatementNode* createConstStatement(const JSTokenLocation& location, ConstDeclNode* decls, int startLine, int endLine)
    {
        ConstStatementNode* result = new (m_globalData) ConstStatementNode(location, decls);
        result->setLoc(startLine, endLine, location.column);
        return result;
    }

    ConstDeclNode* appendConstDecl(const JSTokenLocation& location, ConstDeclNode* tail, const Identifier* name, ExpressionNode* initializer)
    {
        ConstDeclNode* result = new (m_globalData) ConstDeclNode(location, *name, initializer);
        if (tail)
            tail->m_next = result;
        return result;

        m_scope.m_varDeclarations->data.append(std::make_pair(ident, attrs));
    }

    ExpressionNode* combineCommaNodes(const JSTokenLocation& location, ExpressionNode* list, ExpressionNode* init)
    {
        if (!list)
            return init;

            static_cast<CommaNode*>(list)->append(init);
            return list;
        }
        return new (m_globalData) CommaNode(location, list, init);
    }

    int evalCount() const { return m_evalCount; }

        ASSERT(operandStackDepth >= 0);
        m_binaryOperandStack.resize(m_binaryOperandStack.size() - amount);
    }
    void appendBinaryOperation(const JSTokenLocation& location, int& operandStackDepth, int&, const BinaryOperand& lhs, const BinaryOperand& rhs)
    {
        operandStackDepth++;
        m_binaryOperandStack.append(std::make_pair(makeBinaryNode(location, m_binaryOperatorStack.last().first, lhs, rhs), BinaryOpInfo(lhs.second, rhs.second)));
    }
    void operatorStackAppend(int& operatorStackDepth, int op, int precedence)
    {

        m_assignmentInfoStack.append(AssignmentInfo(node, start, divot, assignmentCount, op));
    }

    ExpressionNode* createAssignment(const JSTokenLocation& location, int& assignmentStackDepth, ExpressionNode* rhs, int initialAssignmentCount, int currentAssignmentCount, int lastTokenEnd)
    {
        ExpressionNode* result = makeAssignNode(location, 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;

        m_evalCount++;
        m_scope.m_features |= EvalFeature;
    }
    ExpressionNode* createNumber(const JSTokenLocation& location, double d)
    {
        return new (m_globalData) NumberNode(location, d);
    }
    
    JSGlobalData* m_globalData;

    int m_evalCount;
};

ExpressionNode* ASTBuilder::makeTypeOfNode(const JSTokenLocation& location, ExpressionNode* expr)
{
    if (expr->isResolveNode()) {
        ResolveNode* resolve = static_cast<ResolveNode*>(expr);
        return new (m_globalData) TypeOfResolveNode(location, resolve->identifier());
    }
    return new (m_globalData) TypeOfValueNode(location, expr);
}

ExpressionNode* ASTBuilder::makeDeleteNode(const JSTokenLocation& location, ExpressionNode* expr, int start, int divot, int end)
{
    if (!expr->isLocation())
        return new (m_globalData) DeleteValueNode(location, expr);
    if (expr->isResolveNode()) {
        ResolveNode* resolve = static_cast<ResolveNode*>(expr);
        return new (m_globalData) DeleteResolveNode(location, resolve->identifier(), divot, divot - start, end - divot);
    }
    if (expr->isBracketAccessorNode()) {
        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
        return new (m_globalData) DeleteBracketNode(location, bracket->base(), bracket->subscript(), divot, divot - start, end - divot);
    }
    ASSERT(expr->isDotAccessorNode());
    DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
    return new (m_globalData) DeleteDotNode(location, dot->base(), dot->identifier(), divot, divot - start, end - divot);
}

ExpressionNode* ASTBuilder::makeNegateNode(const JSTokenLocation& location, ExpressionNode* n)
{
    if (n->isNumber()) {
        NumberNode* numberNode = static_cast<NumberNode*>(n);

        return numberNode;
    }

    return new (m_globalData) NegateNode(location, n);
}

ExpressionNode* ASTBuilder::makeBitwiseNotNode(const JSTokenLocation& location, ExpressionNode* expr)
{
    if (expr->isNumber())
        return createNumber(location, ~toInt32(static_cast<NumberNode*>(expr)->value()));
    return new (m_globalData) BitwiseNotNode(location, expr);
}

ExpressionNode* ASTBuilder::makeMultNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
{
    expr1 = expr1->stripUnaryPlus();
    expr2 = expr2->stripUnaryPlus();

    if (expr1->isNumber() && expr2->isNumber())
        return createNumber(location, static_cast<NumberNode*>(expr1)->value() * static_cast<NumberNode*>(expr2)->value());

    if (expr1->isNumber() && static_cast<NumberNode*>(expr1)->value() == 1)
        return new (m_globalData) UnaryPlusNode(location, expr2);

    if (expr2->isNumber() && static_cast<NumberNode*>(expr2)->value() == 1)
        return new (m_globalData) UnaryPlusNode(location, expr1);

    return new (m_globalData) MultNode(location, expr1, expr2, rightHasAssignments);
}

ExpressionNode* ASTBuilder::makeDivNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
{
    expr1 = expr1->stripUnaryPlus();
    expr2 = expr2->stripUnaryPlus();

    if (expr1->isNumber() && expr2->isNumber())
        return createNumber(location, static_cast<NumberNode*>(expr1)->value() / static_cast<NumberNode*>(expr2)->value());
    return new (m_globalData) DivNode(location, expr1, expr2, rightHasAssignments);
}

ExpressionNode* ASTBuilder::makeModNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
{
    expr1 = expr1->stripUnaryPlus();
    expr2 = expr2->stripUnaryPlus();
    
    if (expr1->isNumber() && expr2->isNumber())
        return createNumber(location, fmod(static_cast<NumberNode*>(expr1)->value(), static_cast<NumberNode*>(expr2)->value()));
    return new (m_globalData) ModNode(location, expr1, expr2, rightHasAssignments);
}

ExpressionNode* ASTBuilder::makeAddNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
{
    if (expr1->isNumber() && expr2->isNumber())
        return createNumber(location, static_cast<NumberNode*>(expr1)->value() + static_cast<NumberNode*>(expr2)->value());
    return new (m_globalData) AddNode(location, expr1, expr2, rightHasAssignments);
}

ExpressionNode* ASTBuilder::makeSubNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
{
    expr1 = expr1->stripUnaryPlus();
    expr2 = expr2->stripUnaryPlus();

    if (expr1->isNumber() && expr2->isNumber())
        return createNumber(location, static_cast<NumberNode*>(expr1)->value() - static_cast<NumberNode*>(expr2)->value());
    return new (m_globalData) SubNode(location, expr1, expr2, rightHasAssignments);
}

ExpressionNode* ASTBuilder::makeLeftShiftNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
{
    if (expr1->isNumber() && expr2->isNumber())
        return createNumber(location, toInt32(static_cast<NumberNode*>(expr1)->value()) << (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
    return new (m_globalData) LeftShiftNode(location, expr1, expr2, rightHasAssignments);
}

ExpressionNode* ASTBuilder::makeRightShiftNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
{
    if (expr1->isNumber() && expr2->isNumber())
        return createNumber(location, toInt32(static_cast<NumberNode*>(expr1)->value()) >> (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
    return new (m_globalData) RightShiftNode(location, expr1, expr2, rightHasAssignments);
}

ExpressionNode* ASTBuilder::makeURightShiftNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
{
    if (expr1->isNumber() && expr2->isNumber())
        return createNumber(location, toUInt32(static_cast<NumberNode*>(expr1)->value()) >> (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
    return new (m_globalData) UnsignedRightShiftNode(location, expr1, expr2, rightHasAssignments);
}

ExpressionNode* ASTBuilder::makeBitOrNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
{
    if (expr1->isNumber() && expr2->isNumber())
        return createNumber(location, toInt32(static_cast<NumberNode*>(expr1)->value()) | toInt32(static_cast<NumberNode*>(expr2)->value()));
    return new (m_globalData) BitOrNode(location, expr1, expr2, rightHasAssignments);
}

ExpressionNode* ASTBuilder::makeBitAndNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
{
    if (expr1->isNumber() && expr2->isNumber())
        return createNumber(location, toInt32(static_cast<NumberNode*>(expr1)->value()) & toInt32(static_cast<NumberNode*>(expr2)->value()));
    return new (m_globalData) BitAndNode(location, expr1, expr2, rightHasAssignments);
}

ExpressionNode* ASTBuilder::makeBitXOrNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
{
    if (expr1->isNumber() && expr2->isNumber())
        return createNumber(location, toInt32(static_cast<NumberNode*>(expr1)->value()) ^ toInt32(static_cast<NumberNode*>(expr2)->value()));
    return new (m_globalData) BitXOrNode(location, expr1, expr2, rightHasAssignments);
}

ExpressionNode* ASTBuilder::makeFunctionCallNode(const JSTokenLocation& location, ExpressionNode* func, ArgumentsNode* args, int start, int divot, int end)
{
    if (!func->isLocation())
        return new (m_globalData) FunctionCallValueNode(location, 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(location, args, divot, divot - start, end - divot);
        }
        return new (m_globalData) FunctionCallResolveNode(location, identifier, args, divot, divot - start, end - divot);
    }
    if (func->isBracketAccessorNode()) {
        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(func);
        FunctionCallBracketNode* node = new (m_globalData) FunctionCallBracketNode(location, bracket->base(), bracket->subscript(), args, divot, divot - start, end - divot);
        node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
        return node;
    }

    DotAccessorNode* dot = static_cast<DotAccessorNode*>(func);
    FunctionCallDotNode* node;
    if (dot->identifier() == m_globalData->propertyNames->call)
        node = new (m_globalData) CallFunctionCallDotNode(location, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
    else if (dot->identifier() == m_globalData->propertyNames->apply)
        node = new (m_globalData) ApplyFunctionCallDotNode(location, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
    else
        node = new (m_globalData) FunctionCallDotNode(location, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
    node->setSubexpressionInfo(dot->divot(), dot->endOffset());
    return node;
}

ExpressionNode* ASTBuilder::makeBinaryNode(const JSTokenLocation& location, int token, pair<ExpressionNode*, BinaryOpInfo> lhs, pair<ExpressionNode*, BinaryOpInfo> rhs)
{
    switch (token) {
    case OR:
        return new (m_globalData) LogicalOpNode(location, lhs.first, rhs.first, OpLogicalOr);

    case AND:
        return new (m_globalData) LogicalOpNode(location, lhs.first, rhs.first, OpLogicalAnd);

    case BITOR:
        return makeBitOrNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case BITXOR:
        return makeBitXOrNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case BITAND:
        return makeBitAndNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case EQEQ:
        return new (m_globalData) EqualNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case NE:
        return new (m_globalData) NotEqualNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case STREQ:
        return new (m_globalData) StrictEqualNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case STRNEQ:
        return new (m_globalData) NotStrictEqualNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case LT:
        return new (m_globalData) LessNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case GT:
        return new (m_globalData) GreaterNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case LE:
        return new (m_globalData) LessEqNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case GE:
        return new (m_globalData) GreaterEqNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case INSTANCEOF: {
        InstanceOfNode* node = new (m_globalData) InstanceOfNode(location, 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(location, lhs.first, rhs.first, rhs.second.hasAssignment);
        setExceptionLocation(node, lhs.second.start, rhs.second.start, rhs.second.end);
        return node;
    }

    case LSHIFT:
        return makeLeftShiftNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case RSHIFT:
        return makeRightShiftNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case URSHIFT:
        return makeURightShiftNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case PLUS:
        return makeAddNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case MINUS:
        return makeSubNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case TIMES:
        return makeMultNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case DIVIDE:
        return makeDivNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);

    case MOD:
        return makeModNode(location, lhs.first, rhs.first, rhs.second.hasAssignment);
    }
    CRASH();
    return 0;
}

ExpressionNode* ASTBuilder::makeAssignNode(const JSTokenLocation& location, ExpressionNode* loc, Operator op, ExpressionNode* expr, bool locHasAssignments, bool exprHasAssignments, int start, int divot, int end)
{
    if (!loc->isLocation())
        return new (m_globalData) AssignErrorNode(location, divot, divot - start, end - divot);

    if (loc->isResolveNode()) {
        ResolveNode* resolve = static_cast<ResolveNode*>(loc);
        if (op == OpEqual) {
            if (expr->isFuncExprNode())
                static_cast<FuncExprNode*>(expr)->body()->setInferredName(resolve->identifier());
            AssignResolveNode* node = new (m_globalData) AssignResolveNode(location, resolve->identifier(), expr);
            setExceptionLocation(node, start, divot, end);
            return node;
        }
        return new (m_globalData) ReadModifyResolveNode(location, 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(location, bracket->base(), bracket->subscript(), expr, locHasAssignments, exprHasAssignments, bracket->divot(), bracket->divot() - start, end - bracket->divot());
        ReadModifyBracketNode* node = new (m_globalData) ReadModifyBracketNode(location, bracket->base(), bracket->subscript(), op, expr, locHasAssignments, exprHasAssignments, divot, divot - start, end - divot);
        node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
        return node;
    }

    if (op == OpEqual) {
        if (expr->isFuncExprNode())
            static_cast<FuncExprNode*>(expr)->body()->setInferredName(dot->identifier());
        return new (m_globalData) AssignDotNode(location, dot->base(), dot->identifier(), expr, exprHasAssignments, dot->divot(), dot->divot() - start, end - dot->divot());
    }

    ReadModifyDotNode* node = new (m_globalData) ReadModifyDotNode(location, dot->base(), dot->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
    node->setSubexpressionInfo(dot->divot(), dot->endOffset());
    return node;
}

ExpressionNode* ASTBuilder::makePrefixNode(const JSTokenLocation& location, ExpressionNode* expr, Operator op, int start, int divot, int end)
{
    if (!expr->isLocation())
        return new (m_globalData) PrefixErrorNode(location, op, divot, divot - start, end - divot);

    if (expr->isResolveNode()) {
        ResolveNode* resolve = static_cast<ResolveNode*>(expr);
        return new (m_globalData) PrefixResolveNode(location, resolve->identifier(), op, divot, divot - start, end - divot);
    }
    if (expr->isBracketAccessorNode()) {
        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
        PrefixBracketNode* node = new (m_globalData) PrefixBracketNode(location, 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(location, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
    node->setSubexpressionInfo(dot->divot(), dot->startOffset());
    return node;
}

ExpressionNode* ASTBuilder::makePostfixNode(const JSTokenLocation& location, ExpressionNode* expr, Operator op, int start, int divot, int end)
{
    if (!expr->isLocation())
        return new (m_globalData) PostfixErrorNode(location, op, divot, divot - start, end - divot);

    if (expr->isResolveNode()) {
        ResolveNode* resolve = static_cast<ResolveNode*>(expr);
        return new (m_globalData) PostfixResolveNode(location, resolve->identifier(), op, divot, divot - start, end - divot);
    }
    if (expr->isBracketAccessorNode()) {
        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
        PostfixBracketNode* node = new (m_globalData) PostfixBracketNode(location, 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(location, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
    node->setSubexpressionInfo(dot->divot(), dot->endOffset());
    return node;
}



    m_codeEnd = m_codeStart + source.endOffset();
    m_error = false;
    m_atLineStart = true;
    m_columnNumber = 0;
    m_lexErrorMessage = UString();
    
    m_buffer8.reserveInitialCapacity(initialReadBufferCapacity);

template <int shiftAmount> ALWAYS_INLINE void Lexer<T>::internalShift()
{
    m_code += shiftAmount;
    m_columnNumber += shiftAmount;
    m_current = *m_code;
}


    ++m_code;
    if (LIKELY(m_code < m_codeEnd))
        m_current = *m_code;
    ++m_columnNumber;
}

template <typename T>

}

template <typename T>
JSTokenType Lexer<T>::lex(JSTokenData* tokenData, JSTokenLocation* tokenLocation, unsigned lexerFlags, bool strictMode)
{
    ASSERT(!m_error);
    ASSERT(m_buffer8.isEmpty());

    if (atEnd())
        return EOFTOK;
    
    tokenLocation->startOffset = currentOffset();
    tokenLocation->column = m_columnNumber;

    CharacterType type;
    if (LIKELY(isLatin1(m_current)))

        shiftLineTerminator();
        m_atLineStart = true;
        m_terminator = true;
        m_columnNumber = 0;
        goto start;
    case CharacterInvalid:
        m_lexErrorMessage = invalidCharacterMessage();

    shiftLineTerminator();
    m_atLineStart = true;
    m_terminator = true;
    m_columnNumber = 0;
    if (!lastTokenWasRestrKeyword())
        goto start;


    // Fall through into returnToken.

returnToken:
    tokenLocation->line = m_lineNumber;
    tokenLocation->endOffset = currentOffset();
    m_lastToken = token;
    return token;

returnError:
    m_error = true;
    tokenLocation->line = m_lineNumber;
    tokenLocation->endOffset = currentOffset();
    return ERRORTOK;
}




    void setIsReparsing() { m_isReparsing = true; }
    bool isReparsing() const { return m_isReparsing; }

    JSTokenType lex(JSTokenData*, JSTokenLocation*, unsigned, bool strictMode);
    bool nextTokenIsColon();
    int lineNumber() const { return m_lineNumber; }
    int currentColumnNumber() const { return m_columnNumber; }
    void setLastLineNumber(int lastLineNumber) { m_lastLineNumber = lastLineNumber; }
    int lastLineNumber() const { return m_lastLineNumber; }
    bool prevTerminator() const { return m_terminator; }


    SourceProvider* sourceProvider() const { return m_source->provider(); }

    JSTokenType lexExpectIdentifier(JSTokenData*, JSTokenLocation*, unsigned, bool strictMode);

private:
    void record8(int);


    int m_lineNumber;
    int m_lastLineNumber;
    int m_columnNumber;

    Vector<LChar> m_buffer8;
    Vector<UChar> m_buffer16;

}

template <typename T>
ALWAYS_INLINE JSTokenType Lexer<T>::lexExpectIdentifier(JSTokenData* tokenData, JSTokenLocation* tokenLocation, unsigned lexerFlags, bool strictMode)
{
    ASSERT((lexerFlags & LexerFlagsIgnoreReservedWords));
    const T* start = m_code;

        m_current = 0;

    m_code = ptr;
    m_columnNumber = m_columnNumber + (m_code - start);

    // Create the identifier if needed
    if (lexerFlags & LexexFlagsDontBuildKeywords)
        tokenData->ident = 0;
    else
        tokenData->ident = makeIdentifier(start, ptr - start);
    tokenLocation->line = m_lineNumber;
    tokenLocation->startOffset = start - m_codeStart;
    tokenLocation->endOffset = currentOffset();
    tokenLocation->column = m_columnNumber;
    m_lastToken = IDENT;
    return IDENT;
    
slowCase:
    return lex(tokenData, tokenLocation, lexerFlags, strictMode);
}

} // namespace JSC



        globalData->parserArena->derefWithArena(adoptRef(this));
    }

    inline Node::Node(const JSTokenLocation& location)
        : m_lineNumber(location.line)
        , m_columnNumber(location.column)
    {
    }

    inline ExpressionNode::ExpressionNode(const JSTokenLocation& location, ResultType resultType)
        : Node(location)
        , m_resultType(resultType)
    {
    }

    inline StatementNode::StatementNode(const JSTokenLocation& location)
        : Node(location)
        , m_lastLine(-1)
    {
    }

    inline NullNode::NullNode(const JSTokenLocation& location)
        : ExpressionNode(location, ResultType::nullType())
    {
    }

    inline BooleanNode::BooleanNode(const JSTokenLocation& location, bool value)
        : ExpressionNode(location, ResultType::booleanType())
        , m_value(value)
    {
    }

    inline NumberNode::NumberNode(const JSTokenLocation& location, double value)
        : ExpressionNode(location, ResultType::numberType())
        , m_value(value)
    {
    }

    inline StringNode::StringNode(const JSTokenLocation& location, const Identifier& value)
        : ExpressionNode(location, ResultType::stringType())
        , m_value(value)
    {
    }

    inline RegExpNode::RegExpNode(const JSTokenLocation& location, const Identifier& pattern, const Identifier& flags)
        : ExpressionNode(location)
        , m_pattern(pattern)
        , m_flags(flags)
    {
    }

    inline ThisNode::ThisNode(const JSTokenLocation& location)
        : ExpressionNode(location)
    {
    }

    inline ResolveNode::ResolveNode(const JSTokenLocation& location, const Identifier& ident, int startOffset)
        : ExpressionNode(location)
        , m_ident(ident)
        , m_startOffset(startOffset)
    {

        l->m_next = this;
    }

    inline ArrayNode::ArrayNode(const JSTokenLocation& location, int elision)
        : ExpressionNode(location)
        , m_element(0)
        , m_elision(elision)
        , m_optional(true)
    {
    }

    inline ArrayNode::ArrayNode(const JSTokenLocation& location, ElementNode* element)
        : ExpressionNode(location)
        , m_element(element)
        , m_elision(0)
        , m_optional(false)
    {
    }

    inline ArrayNode::ArrayNode(const JSTokenLocation& location, int elision, ElementNode* element)
        : ExpressionNode(location)
        , m_element(element)
        , m_elision(elision)
        , m_optional(true)

    {
    }

    inline PropertyListNode::PropertyListNode(const JSTokenLocation& location, PropertyNode* node)
        : Node(location)
        , m_node(node)
        , m_next(0)
    {
    }

    inline PropertyListNode::PropertyListNode(const JSTokenLocation& location, PropertyNode* node, PropertyListNode* list)
        : Node(location)
        , m_node(node)
        , m_next(0)
    {
        list->m_next = this;
    }

    inline ObjectLiteralNode::ObjectLiteralNode(const JSTokenLocation& location)
        : ExpressionNode(location)
        , m_list(0)
    {
    }

    inline ObjectLiteralNode::ObjectLiteralNode(const JSTokenLocation& location, PropertyListNode* list)
        : ExpressionNode(location)
        , m_list(list)
    {
    }

    inline BracketAccessorNode::BracketAccessorNode(const JSTokenLocation& location, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments)
        : ExpressionNode(location)
        , m_base(base)
        , m_subscript(subscript)
        , m_subscriptHasAssignments(subscriptHasAssignments)
    {
    }

    inline DotAccessorNode::DotAccessorNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident)
        : ExpressionNode(location)
        , m_base(base)
        , m_ident(ident)
    {
    }

    inline ArgumentListNode::ArgumentListNode(const JSTokenLocation& location, ExpressionNode* expr)
        : Node(location)
        , m_next(0)
        , m_expr(expr)
    {
    }

    inline ArgumentListNode::ArgumentListNode(const JSTokenLocation& location, ArgumentListNode* listNode, ExpressionNode* expr)
        : Node(location)
        , m_next(0)
        , m_expr(expr)
    {

    {
    }

    inline NewExprNode::NewExprNode(const JSTokenLocation& location, ExpressionNode* expr)
        : ExpressionNode(location)
        , m_expr(expr)
        , m_args(0)
    {
    }

    inline NewExprNode::NewExprNode(const JSTokenLocation& location, ExpressionNode* expr, ArgumentsNode* args)
        : ExpressionNode(location)
        , m_expr(expr)
        , m_args(args)
    {
    }

    inline EvalFunctionCallNode::EvalFunctionCallNode(const JSTokenLocation& location, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableExpressionData(divot, startOffset, endOffset)
        , m_args(args)
    {
    }

    inline FunctionCallValueNode::FunctionCallValueNode(const JSTokenLocation& location, ExpressionNode* expr, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableExpressionData(divot, startOffset, endOffset)
        , m_expr(expr)
        , m_args(args)
    {
    }

    inline FunctionCallResolveNode::FunctionCallResolveNode(const JSTokenLocation& location, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableExpressionData(divot, startOffset, endOffset)
        , m_ident(ident)
        , m_args(args)
    {
    }

    inline FunctionCallBracketNode::FunctionCallBracketNode(const JSTokenLocation& location, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableSubExpressionData(divot, startOffset, endOffset)
        , m_base(base)
        , m_subscript(subscript)

    {
    }

    inline FunctionCallDotNode::FunctionCallDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableSubExpressionData(divot, startOffset, endOffset)
        , m_base(base)
        , m_ident(ident)

    {
    }

    inline CallFunctionCallDotNode::CallFunctionCallDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
        : FunctionCallDotNode(location, base, ident, args, divot, startOffset, endOffset)
    {
    }

    inline ApplyFunctionCallDotNode::ApplyFunctionCallDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
        : FunctionCallDotNode(location, base, ident, args, divot, startOffset, endOffset)
    {
    }

    inline PrePostResolveNode::PrePostResolveNode(const JSTokenLocation& location, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location, ResultType::numberType()) // could be reusable for pre?
        , ThrowableExpressionData(divot, startOffset, endOffset)
        , m_ident(ident)
    {
    }

    inline PostfixResolveNode::PostfixResolveNode(const JSTokenLocation& location, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
        : PrePostResolveNode(location, ident, divot, startOffset, endOffset)
        , m_operator(oper)
    {
    }

    inline PostfixBracketNode::PostfixBracketNode(const JSTokenLocation& location, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableSubExpressionData(divot, startOffset, endOffset)
        , m_base(base)
        , m_subscript(subscript)

    {
    }

    inline PostfixDotNode::PostfixDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableSubExpressionData(divot, startOffset, endOffset)
        , m_base(base)
        , m_ident(ident)

    {
    }

    inline PostfixErrorNode::PostfixErrorNode(const JSTokenLocation& location, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableSubExpressionData(divot, startOffset, endOffset)
        , m_operator(oper)
    {
    }

    inline DeleteResolveNode::DeleteResolveNode(const JSTokenLocation& location, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableExpressionData(divot, startOffset, endOffset)
        , m_ident(ident)
    {
    }

    inline DeleteBracketNode::DeleteBracketNode(const JSTokenLocation& location, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableExpressionData(divot, startOffset, endOffset)
        , m_base(base)
        , m_subscript(subscript)
    {
    }

    inline DeleteDotNode::DeleteDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableExpressionData(divot, startOffset, endOffset)
        , m_base(base)
        , m_ident(ident)
    {
    }

    inline DeleteValueNode::DeleteValueNode(const JSTokenLocation& location, ExpressionNode* expr)
        : ExpressionNode(location)
        , m_expr(expr)
    {
    }

    inline VoidNode::VoidNode(const JSTokenLocation& location, ExpressionNode* expr)
        : ExpressionNode(location)
        , m_expr(expr)
    {
    }

    inline TypeOfResolveNode::TypeOfResolveNode(const JSTokenLocation& location, const Identifier& ident)
        : ExpressionNode(location, ResultType::stringType())
        , m_ident(ident)
    {
    }

    inline TypeOfValueNode::TypeOfValueNode(const JSTokenLocation& location, ExpressionNode* expr)
        : ExpressionNode(location, ResultType::stringType())
        , m_expr(expr)
    {
    }

    inline PrefixResolveNode::PrefixResolveNode(const JSTokenLocation& location, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
        : PrePostResolveNode(location, ident, divot, startOffset, endOffset)
        , m_operator(oper)
    {
    }

    inline PrefixBracketNode::PrefixBracketNode(const JSTokenLocation& location, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowablePrefixedSubExpressionData(divot, startOffset, endOffset)
        , m_base(base)
        , m_subscript(subscript)

    {
    }

    inline PrefixDotNode::PrefixDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowablePrefixedSubExpressionData(divot, startOffset, endOffset)
        , m_base(base)
        , m_ident(ident)

    {
    }

    inline PrefixErrorNode::PrefixErrorNode(const JSTokenLocation& location, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableExpressionData(divot, startOffset, endOffset)
        , m_operator(oper)
    {
    }

    inline UnaryOpNode::UnaryOpNode(const JSTokenLocation& location, ResultType type, ExpressionNode* expr, OpcodeID opcodeID)
        : ExpressionNode(location, type)
        , m_expr(expr)
        , m_opcodeID(opcodeID)
    {
    }

    inline UnaryPlusNode::UnaryPlusNode(const JSTokenLocation& location, ExpressionNode* expr)
        : UnaryOpNode(location, ResultType::numberType(), expr, op_to_jsnumber)
    {
    }

    inline NegateNode::NegateNode(const JSTokenLocation& location, ExpressionNode* expr)
        : UnaryOpNode(location, ResultType::numberType(), expr, op_negate)
    {
    }

    inline BitwiseNotNode::BitwiseNotNode(const JSTokenLocation& location, ExpressionNode* expr)
        : ExpressionNode(location, ResultType::forBitOp())
        , m_expr(expr)
    {
    }

    inline LogicalNotNode::LogicalNotNode(const JSTokenLocation& location, ExpressionNode* expr)
        : UnaryOpNode(location, ResultType::booleanType(), expr, op_not)
    {
    }

    inline BinaryOpNode::BinaryOpNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
        : ExpressionNode(location)
        , m_expr1(expr1)
        , m_expr2(expr2)
        , m_opcodeID(opcodeID)

    {
    }

    inline BinaryOpNode::BinaryOpNode(const JSTokenLocation& location, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
        : ExpressionNode(location, type)
        , m_expr1(expr1)
        , m_expr2(expr2)
        , m_opcodeID(opcodeID)

    {
    }

    inline MultNode::MultNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::numberType(), expr1, expr2, op_mul, rightHasAssignments)
    {
    }

    inline DivNode::DivNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::numberType(), expr1, expr2, op_div, rightHasAssignments)
    {
    }


    inline ModNode::ModNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::numberType(), expr1, expr2, op_mod, rightHasAssignments)
    {
    }

    inline AddNode::AddNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::forAdd(expr1->resultDescriptor(), expr2->resultDescriptor()), expr1, expr2, op_add, rightHasAssignments)
    {
    }

    inline SubNode::SubNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::numberType(), expr1, expr2, op_sub, rightHasAssignments)
    {
    }

    inline LeftShiftNode::LeftShiftNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::forBitOp(), expr1, expr2, op_lshift, rightHasAssignments)
    {
    }

    inline RightShiftNode::RightShiftNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::forBitOp(), expr1, expr2, op_rshift, rightHasAssignments)
    {
    }

    inline UnsignedRightShiftNode::UnsignedRightShiftNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::numberType(), expr1, expr2, op_urshift, rightHasAssignments)
    {
    }

    inline LessNode::LessNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::booleanType(), expr1, expr2, op_less, rightHasAssignments)
    {
    }

    inline GreaterNode::GreaterNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::booleanType(), expr1, expr2, op_greater, rightHasAssignments)
    {
    }

    inline LessEqNode::LessEqNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::booleanType(), expr1, expr2, op_lesseq, rightHasAssignments)
    {
    }

    inline GreaterEqNode::GreaterEqNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::booleanType(), expr1, expr2, op_greatereq, rightHasAssignments)
    {
    }

    inline ThrowableBinaryOpNode::ThrowableBinaryOpNode(const JSTokenLocation& location, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
        : BinaryOpNode(location, type, expr1, expr2, opcodeID, rightHasAssignments)
    {
    }

    inline ThrowableBinaryOpNode::ThrowableBinaryOpNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
        : BinaryOpNode(location, expr1, expr2, opcodeID, rightHasAssignments)
    {
    }

    inline InstanceOfNode::InstanceOfNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : ThrowableBinaryOpNode(location, ResultType::booleanType(), expr1, expr2, op_instanceof, rightHasAssignments)
    {
    }

    inline InNode::InNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : ThrowableBinaryOpNode(location, expr1, expr2, op_in, rightHasAssignments)
    {
    }

    inline EqualNode::EqualNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::booleanType(), expr1, expr2, op_eq, rightHasAssignments)
    {
    }

    inline NotEqualNode::NotEqualNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::booleanType(), expr1, expr2, op_neq, rightHasAssignments)
    {
    }

    inline StrictEqualNode::StrictEqualNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::booleanType(), expr1, expr2, op_stricteq, rightHasAssignments)
    {
    }

    inline NotStrictEqualNode::NotStrictEqualNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::booleanType(), expr1, expr2, op_nstricteq, rightHasAssignments)
    {
    }

    inline BitAndNode::BitAndNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::forBitOp(), expr1, expr2, op_bitand, rightHasAssignments)
    {
    }

    inline BitOrNode::BitOrNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::forBitOp(), expr1, expr2, op_bitor, rightHasAssignments)
    {
    }

    inline BitXOrNode::BitXOrNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
        : BinaryOpNode(location, ResultType::forBitOp(), expr1, expr2, op_bitxor, rightHasAssignments)
    {
    }

    inline LogicalOpNode::LogicalOpNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator oper)
        : ExpressionNode(location, ResultType::booleanType())
        , m_expr1(expr1)
        , m_expr2(expr2)
        , m_operator(oper)
    {
    }

    inline ConditionalNode::ConditionalNode(const JSTokenLocation& location, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2)
        : ExpressionNode(location)
        , m_logical(logical)
        , m_expr1(expr1)
        , m_expr2(expr2)
    {
    }

    inline ReadModifyResolveNode::ReadModifyResolveNode(const JSTokenLocation& location, const Identifier& ident, Operator oper, ExpressionNode*  right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableExpressionData(divot, startOffset, endOffset)
        , m_ident(ident)
        , m_right(right)

    {
    }

    inline AssignResolveNode::AssignResolveNode(const JSTokenLocation& location, const Identifier& ident, ExpressionNode* right)
        : ExpressionNode(location)
        , m_ident(ident)
        , m_right(right)
    {
    }

    inline ReadModifyBracketNode::ReadModifyBracketNode(const JSTokenLocation& location, ExpressionNode* base, ExpressionNode* subscript, Operator oper, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableSubExpressionData(divot, startOffset, endOffset)
        , m_base(base)
        , m_subscript(subscript)

    {
    }

    inline AssignBracketNode::AssignBracketNode(const JSTokenLocation& location, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableExpressionData(divot, startOffset, endOffset)
        , m_base(base)
        , m_subscript(subscript)

    {
    }

    inline AssignDotNode::AssignDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableExpressionData(divot, startOffset, endOffset)
        , m_base(base)
        , m_ident(ident)

    {
    }

    inline ReadModifyDotNode::ReadModifyDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, Operator oper, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableSubExpressionData(divot, startOffset, endOffset)
        , m_base(base)
        , m_ident(ident)

    {
    }

    inline AssignErrorNode::AssignErrorNode(const JSTokenLocation& location, unsigned divot, unsigned startOffset, unsigned endOffset)
        : ExpressionNode(location)
        , ThrowableExpressionData(divot, startOffset, endOffset)
    {
    }

    inline CommaNode::CommaNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2)
        : ExpressionNode(location)
    {
        m_expressions.append(expr1);
        m_expressions.append(expr2);
    }

    inline ConstStatementNode::ConstStatementNode(const JSTokenLocation& location, ConstDeclNode* next)
        : StatementNode(location)
        , m_next(next)
    {
    }

    {
    }

    inline EmptyStatementNode::EmptyStatementNode(const JSTokenLocation& location)
        : StatementNode(location)
    {
    }

    inline DebuggerStatementNode::DebuggerStatementNode(const JSTokenLocation& location)
        : StatementNode(location)
    {
    }
    
    inline ExprStatementNode::ExprStatementNode(const JSTokenLocation& location, ExpressionNode* expr)
        : StatementNode(location)
        , m_expr(expr)
    {
    }

    inline VarStatementNode::VarStatementNode(const JSTokenLocation& location, ExpressionNode* expr)
        : StatementNode(location)
        , m_expr(expr)
    {
    }
    
    inline IfNode::IfNode(const JSTokenLocation& location, ExpressionNode* condition, StatementNode* ifBlock)
        : StatementNode(location)
        , m_condition(condition)
        , m_ifBlock(ifBlock)
    {
    }

    inline IfElseNode::IfElseNode(const JSTokenLocation& location, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock)
        : IfNode(location, condition, ifBlock)
        , m_elseBlock(elseBlock)
    {
    }

    inline DoWhileNode::DoWhileNode(const JSTokenLocation& location, StatementNode* statement, ExpressionNode* expr)
        : StatementNode(location)
        , m_statement(statement)
        , m_expr(expr)
    {
    }

    inline WhileNode::WhileNode(const JSTokenLocation& location, ExpressionNode* expr, StatementNode* statement)
        : StatementNode(location)
        , m_expr(expr)
        , m_statement(statement)
    {
    }

    inline ForNode::ForNode(const JSTokenLocation& location, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement)
        : StatementNode(location)
        , m_expr1(expr1)
        , m_expr2(expr2)
        , m_expr3(expr3)

        ASSERT(statement);
    }

    inline ContinueNode::ContinueNode(JSGlobalData* globalData, const JSTokenLocation& location)
        : StatementNode(location)
        , m_ident(globalData->propertyNames->nullIdentifier)
    {
    }

    inline ContinueNode::ContinueNode(const JSTokenLocation& location, const Identifier& ident)
        : StatementNode(location)
        , m_ident(ident)
    {
    }
    
    inline BreakNode::BreakNode(JSGlobalData* globalData, const JSTokenLocation& location)
        : StatementNode(location)
        , m_ident(globalData->propertyNames->nullIdentifier)
    {
    }

    inline BreakNode::BreakNode(const JSTokenLocation& location, const Identifier& ident)
        : StatementNode(location)
        , m_ident(ident)
    {
    }
    
    inline ReturnNode::ReturnNode(const JSTokenLocation& location, ExpressionNode* value)
        : StatementNode(location)
        , m_value(value)
    {
    }

    inline WithNode::WithNode(const JSTokenLocation& location, ExpressionNode* expr, StatementNode* statement, uint32_t divot, uint32_t expressionLength)
        : StatementNode(location)
        , m_expr(expr)
        , m_statement(statement)
        , m_divot(divot)

    {
    }

    inline LabelNode::LabelNode(const JSTokenLocation& location, const Identifier& name, StatementNode* statement)
        : StatementNode(location)
        , m_name(name)
        , m_statement(statement)
    {
    }

    inline ThrowNode::ThrowNode(const JSTokenLocation& location, ExpressionNode* expr)
        : StatementNode(location)
        , m_expr(expr)
    {
    }

    inline TryNode::TryNode(const JSTokenLocation& location, StatementNode* tryBlock, const Identifier& exceptionIdent, StatementNode* catchBlock, StatementNode* finallyBlock)
        : StatementNode(location)
        , m_tryBlock(tryBlock)
        , m_exceptionIdent(exceptionIdent)
        , m_catchBlock(catchBlock)

        l->m_next = this;
    }

    inline FuncExprNode::FuncExprNode(const JSTokenLocation& location, const Identifier& ident, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter)
        : ExpressionNode(location)
        , m_body(body)
    {
        m_body->finishParsing(source, parameter, ident);
    }

    inline FuncDeclNode::FuncDeclNode(const JSTokenLocation& location, const Identifier& ident, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter)
        : StatementNode(location)
        , m_body(body)
    {
        m_body->finishParsing(source, parameter, ident);

    {
    }

    inline SwitchNode::SwitchNode(const JSTokenLocation& location, ExpressionNode* expr, CaseBlockNode* block)
        : StatementNode(location)
        , m_expr(expr)
        , m_block(block)
    {
    }

    inline ConstDeclNode::ConstDeclNode(const JSTokenLocation& location, const Identifier& ident, ExpressionNode* init)
        : ExpressionNode(location)
        , m_ident(ident)
        , m_next(0)
        , m_init(init)
    {
    }

    inline BlockNode::BlockNode(const JSTokenLocation& location, SourceElements* statements)
        : StatementNode(location)
        , m_statements(statements)
    {
    }

    inline ForInNode::ForInNode(const JSTokenLocation& location, ExpressionNode* l, ExpressionNode* expr, StatementNode* statement)
        : StatementNode(location)
        , m_init(0)
        , m_lexpr(l)
        , m_expr(expr)

    {
    }

    inline ForInNode::ForInNode(JSGlobalData* globalData, const JSTokenLocation& location, const Identifier& ident, ExpressionNode* in, ExpressionNode* expr, StatementNode* statement, int divot, int startOffset, int endOffset)
        : StatementNode(location)
        , m_init(0)
        , m_lexpr(new (globalData) ResolveNode(location, ident, divot - startOffset))
        , m_expr(expr)
        , m_statement(statement)
        , m_identIsVarDecl(true)
    {
        if (in) {
            AssignResolveNode* node = new (globalData) AssignResolveNode(location, ident, in);
            node->setExceptionSourceCode(divot, divot - startOffset, endOffset - divot);
            m_init = node;
        }




// ------------------------------ StatementNode --------------------------------

void StatementNode::setLoc(int firstLine, int lastLine, int column)
{
    m_lineNumber = firstLine;
    m_lastLine = lastLine;
    m_columnNumber = column;
}

void StatementNode::setLoc(int firstLine, int lastLine)
{
    m_lineNumber = firstLine;
    m_lastLine = lastLine;
    m_columnNumber = 0;
}

// ------------------------------ SourceElements --------------------------------


// ------------------------------ ScopeNode -----------------------------

ScopeNode::ScopeNode(JSGlobalData* globalData, const JSTokenLocation& location, bool inStrictContext)
    : StatementNode(location)
    , ParserArenaRefCounted(globalData)
    , m_features(inStrictContext ? StrictModeFeature : NoFeatures)
    , m_numConstants(0)

{
}

ScopeNode::ScopeNode(JSGlobalData* globalData, const JSTokenLocation& location, const SourceCode& source, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, CodeFeatures features, int numConstants)
    : StatementNode(location)
    , ParserArenaRefCounted(globalData)
    , m_features(features)
    , m_source(source)


// ------------------------------ ProgramNode -----------------------------

inline ProgramNode::ProgramNode(JSGlobalData* globalData, const JSTokenLocation& location, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
    : ScopeNode(globalData, location, source, children, varStack, funcStack, capturedVariables, features, numConstants)
{
}

PassRefPtr<ProgramNode> ProgramNode::create(JSGlobalData* globalData, const JSTokenLocation& location, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
{
    RefPtr<ProgramNode> node = new ProgramNode(globalData, location, children, varStack, funcStack,  capturedVariables, source, features, numConstants);

    ASSERT(node->m_arena.last() == node);
    node->m_arena.removeLast();


// ------------------------------ EvalNode -----------------------------

inline EvalNode::EvalNode(JSGlobalData* globalData, const JSTokenLocation& location, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
    : ScopeNode(globalData, location, source, children, varStack, funcStack, capturedVariables, features, numConstants)
{
}

PassRefPtr<EvalNode> EvalNode::create(JSGlobalData* globalData, const JSTokenLocation& location, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
{
    RefPtr<EvalNode> node = new EvalNode(globalData, location, children, varStack, funcStack, capturedVariables, source, features, numConstants);

    ASSERT(node->m_arena.last() == node);
    node->m_arena.removeLast();

        append(parameter->ident());
}

inline FunctionBodyNode::FunctionBodyNode(JSGlobalData* globalData, const JSTokenLocation& location, bool inStrictContext)
    : ScopeNode(globalData, location, inStrictContext)
{
}

inline FunctionBodyNode::FunctionBodyNode(JSGlobalData* globalData, const JSTokenLocation& location, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& sourceCode, CodeFeatures features, int numConstants)
    : ScopeNode(globalData, location, sourceCode, children, varStack, funcStack, capturedVariables, features, numConstants)
{
}


    m_ident = ident;
}

FunctionBodyNode* FunctionBodyNode::create(JSGlobalData* globalData, const JSTokenLocation& location, bool inStrictContext)
{
    return new FunctionBodyNode(globalData, location, inStrictContext);
}

PassRefPtr<FunctionBodyNode> FunctionBodyNode::create(JSGlobalData* globalData, const JSTokenLocation& location, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& sourceCode, CodeFeatures features, int numConstants)
{
    RefPtr<FunctionBodyNode> node = new FunctionBodyNode(globalData, location, children, varStack, funcStack, capturedVariables, sourceCode, features, numConstants);

    ASSERT(node->m_arena.last() == node);
    node->m_arena.removeLast();

Lines 130-136 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec1
- a/Source/JavaScriptCore/parser/Nodes.h -124 / +128 lines
130		130
131	class Node : public ParserArenaFreeable {	131	class Node : public ParserArenaFreeable {
132	protected:	132	protected:
133	Node(int);	133	Node(const JSTokenLocation&);
134		134
135	public:	135	public:
136	virtual ~Node() { }	136	virtual ~Node() { }
Lines 139-151 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec2
139		139
140	int lineNo() const { return m_lineNumber; }	140	int lineNo() const { return m_lineNumber; }
141		141
		142	int columnNo() const { return m_columnNumber; }
		143
142	protected:	144	protected:
143	int m_lineNumber;	145	int m_lineNumber;
		146	int m_columnNumber;
144	};	147	};
145		148
146	class ExpressionNode : public Node {	149	class ExpressionNode : public Node {
147	protected:	150	protected:
148	ExpressionNode(int, ResultType = ResultType::unknownType());	151	ExpressionNode(const JSTokenLocation&, ResultType = ResultType::unknownType());
149		152
150	public:	153	public:
151	virtual bool isNumber() const { return false; }	154	virtual bool isNumber() const { return false; }
Lines 175-186 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec3
175		178
176	class StatementNode : public Node {	179	class StatementNode : public Node {
177	protected:	180	protected:
178	StatementNode(int);	181	StatementNode(const JSTokenLocation&);
179		182
180	public:	183	public:
181	JS_EXPORT_PRIVATE void setLoc(int firstLine, int lastLine);	184	JS_EXPORT_PRIVATE void setLoc(int firstLine, int lastLine);
		185	void setLoc(int firstLine, int lastLine, int column);
182	int firstLine() const { return lineNo(); }	186	int firstLine() const { return lineNo(); }
183	int lastLine() const { return m_lastLine; }	187	int lastLine() const { return m_lastLine; }
		188	int column() const { return columnNo();}
184		189
185	virtual bool isEmptyStatement() const { return false; }	190	virtual bool isEmptyStatement() const { return false; }
186	virtual bool isReturnNode() const { return false; }	191	virtual bool isReturnNode() const { return false; }
Lines 194-200 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec4
194		199
195	class NullNode : public ExpressionNode {	200	class NullNode : public ExpressionNode {
196	public:	201	public:
197	NullNode(int);	202	NullNode(const JSTokenLocation&);
198		203
199	private:	204	private:
200	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	205	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 204-210 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec5
204		209
205	class BooleanNode : public ExpressionNode {	210	class BooleanNode : public ExpressionNode {
206	public:	211	public:
207	BooleanNode(int, bool value);	212	BooleanNode(const JSTokenLocation&, bool value);
208		213
209	private:	214	private:
210	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	215	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 216-222 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec6
216		221
217	class NumberNode : public ExpressionNode {	222	class NumberNode : public ExpressionNode {
218	public:	223	public:
219	NumberNode(int, double value);	224	NumberNode(const JSTokenLocation&, double value);
220		225
221	double value() const { return m_value; }	226	double value() const { return m_value; }
222	void setValue(double value) { m_value = value; }	227	void setValue(double value) { m_value = value; }
Lines 232-238 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec7
232		237
233	class StringNode : public ExpressionNode {	238	class StringNode : public ExpressionNode {
234	public:	239	public:
235	StringNode(int, const Identifier&);	240	StringNode(const JSTokenLocation&, const Identifier&);
236		241
237	const Identifier& value() { return m_value; }	242	const Identifier& value() { return m_value; }
238		243
Lines 342-348 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec8
342		347
343	class RegExpNode : public ExpressionNode, public ThrowableExpressionData {	348	class RegExpNode : public ExpressionNode, public ThrowableExpressionData {
344	public:	349	public:
345	RegExpNode(int, const Identifier& pattern, const Identifier& flags);	350	RegExpNode(const JSTokenLocation&, const Identifier& pattern, const Identifier& flags);
346		351
347	private:	352	private:
348	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	353	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 353-359 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec9
353		358
354	class ThisNode : public ExpressionNode {	359	class ThisNode : public ExpressionNode {
355	public:	360	public:
356	ThisNode(int);	361	ThisNode(const JSTokenLocation&);
357		362
358	private:	363	private:
359	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	364	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 361-367 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec10
361		366
362	class ResolveNode : public ExpressionNode {	367	class ResolveNode : public ExpressionNode {
363	public:	368	public:
364	ResolveNode(int, const Identifier&, int startOffset);	369	ResolveNode(const JSTokenLocation&, const Identifier&, int startOffset);
365		370
366	const Identifier& identifier() const { return m_ident; }	371	const Identifier& identifier() const { return m_ident; }
367		372
Lines 393-403 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec11
393		398
394	class ArrayNode : public ExpressionNode {	399	class ArrayNode : public ExpressionNode {
395	public:	400	public:
396	ArrayNode(int, int elision);	401	ArrayNode(const JSTokenLocation&, int elision);
397	ArrayNode(int, ElementNode*);	402	ArrayNode(const JSTokenLocation&, ElementNode*);
398	ArrayNode(int, int elision, ElementNode*);	403	ArrayNode(const JSTokenLocation&, int elision, ElementNode*);
399		404
400	ArgumentListNode* toArgumentList(JSGlobalData*, int) const;	405	ArgumentListNode* toArgumentList(JSGlobalData*, int, int) const;
401		406
402	private:	407	private:
403	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	408	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 428-435 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec12
428		433
429	class PropertyListNode : public Node {	434	class PropertyListNode : public Node {
430	public:	435	public:
431	PropertyListNode(int, PropertyNode*);	436	PropertyListNode(const JSTokenLocation&, PropertyNode*);
432	PropertyListNode(int, PropertyNode, PropertyListNode);	437	PropertyListNode(const JSTokenLocation&, PropertyNode, PropertyListNode);
433		438
434	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	439	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
435		440
Lines 440-447 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec13
440		445
441	class ObjectLiteralNode : public ExpressionNode {	446	class ObjectLiteralNode : public ExpressionNode {
442	public:	447	public:
443	ObjectLiteralNode(int);	448	ObjectLiteralNode(const JSTokenLocation&);
444	ObjectLiteralNode(int, PropertyListNode*);	449	ObjectLiteralNode(const JSTokenLocation&, PropertyListNode*);
445		450
446	private:	451	private:
447	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	452	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 451-457 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec14
451		456
452	class BracketAccessorNode : public ExpressionNode, public ThrowableExpressionData {	457	class BracketAccessorNode : public ExpressionNode, public ThrowableExpressionData {
453	public:	458	public:
454	BracketAccessorNode(int, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments);	459	BracketAccessorNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments);
455		460
456	ExpressionNode* base() const { return m_base; }	461	ExpressionNode* base() const { return m_base; }
457	ExpressionNode* subscript() const { return m_subscript; }	462	ExpressionNode* subscript() const { return m_subscript; }
Lines 469-475 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec15
469		474
470	class DotAccessorNode : public ExpressionNode, public ThrowableExpressionData {	475	class DotAccessorNode : public ExpressionNode, public ThrowableExpressionData {
471	public:	476	public:
472	DotAccessorNode(int, ExpressionNode* base, const Identifier&);	477	DotAccessorNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&);
473		478
474	ExpressionNode* base() const { return m_base; }	479	ExpressionNode* base() const { return m_base; }
475	const Identifier& identifier() const { return m_ident; }	480	const Identifier& identifier() const { return m_ident; }
Lines 486-493 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec16
486		491
487	class ArgumentListNode : public Node {	492	class ArgumentListNode : public Node {
488	public:	493	public:
489	ArgumentListNode(int, ExpressionNode*);	494	ArgumentListNode(const JSTokenLocation&, ExpressionNode*);
490	ArgumentListNode(int, ArgumentListNode, ExpressionNode);	495	ArgumentListNode(const JSTokenLocation&, ArgumentListNode, ExpressionNode);
491		496
492	ArgumentListNode* m_next;	497	ArgumentListNode* m_next;
493	ExpressionNode* m_expr;	498	ExpressionNode* m_expr;
Lines 506-513 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec17
506		511
507	class NewExprNode : public ExpressionNode, public ThrowableExpressionData {	512	class NewExprNode : public ExpressionNode, public ThrowableExpressionData {
508	public:	513	public:
509	NewExprNode(int, ExpressionNode*);	514	NewExprNode(const JSTokenLocation&, ExpressionNode*);
510	NewExprNode(int, ExpressionNode, ArgumentsNode);	515	NewExprNode(const JSTokenLocation&, ExpressionNode, ArgumentsNode);
511		516
512	private:	517	private:
513	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	518	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 518-524 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec18
518		523
519	class EvalFunctionCallNode : public ExpressionNode, public ThrowableExpressionData {	524	class EvalFunctionCallNode : public ExpressionNode, public ThrowableExpressionData {
520	public:	525	public:
521	EvalFunctionCallNode(int, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);	526	EvalFunctionCallNode(const JSTokenLocation&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
522		527
523	private:	528	private:
524	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	529	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 528-534 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec19
528		533
529	class FunctionCallValueNode : public ExpressionNode, public ThrowableExpressionData {	534	class FunctionCallValueNode : public ExpressionNode, public ThrowableExpressionData {
530	public:	535	public:
531	FunctionCallValueNode(int, ExpressionNode, ArgumentsNode, unsigned divot, unsigned startOffset, unsigned endOffset);	536	FunctionCallValueNode(const JSTokenLocation&, ExpressionNode, ArgumentsNode, unsigned divot, unsigned startOffset, unsigned endOffset);
532		537
533	private:	538	private:
534	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	539	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 539-545 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec20
539		544
540	class FunctionCallResolveNode : public ExpressionNode, public ThrowableExpressionData {	545	class FunctionCallResolveNode : public ExpressionNode, public ThrowableExpressionData {
541	public:	546	public:
542	FunctionCallResolveNode(int, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);	547	FunctionCallResolveNode(const JSTokenLocation&, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
543		548
544	private:	549	private:
545	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	550	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 550-556 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec21
550		555
551	class FunctionCallBracketNode : public ExpressionNode, public ThrowableSubExpressionData {	556	class FunctionCallBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
552	public:	557	public:
553	FunctionCallBracketNode(int, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);	558	FunctionCallBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
554		559
555	private:	560	private:
556	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	561	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 562-568 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec22
562		567
563	class FunctionCallDotNode : public ExpressionNode, public ThrowableSubExpressionData {	568	class FunctionCallDotNode : public ExpressionNode, public ThrowableSubExpressionData {
564	public:	569	public:
565	FunctionCallDotNode(int, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);	570	FunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
566		571
567	private:	572	private:
568	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	573	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 575-581 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec23
575		580
576	class CallFunctionCallDotNode : public FunctionCallDotNode {	581	class CallFunctionCallDotNode : public FunctionCallDotNode {
577	public:	582	public:
578	CallFunctionCallDotNode(int, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);	583	CallFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
579		584
580	private:	585	private:
581	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	586	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 583-589 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec24
583		588
584	class ApplyFunctionCallDotNode : public FunctionCallDotNode {	589	class ApplyFunctionCallDotNode : public FunctionCallDotNode {
585	public:	590	public:
586	ApplyFunctionCallDotNode(int, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);	591	ApplyFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
587		592
588	private:	593	private:
589	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	594	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 591-597 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec25
591		596
592	class PrePostResolveNode : public ExpressionNode, public ThrowableExpressionData {	597	class PrePostResolveNode : public ExpressionNode, public ThrowableExpressionData {
593	public:	598	public:
594	PrePostResolveNode(int, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);	599	PrePostResolveNode(const JSTokenLocation&, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
595		600
596	protected:	601	protected:
597	const Identifier& m_ident;	602	const Identifier& m_ident;
Lines 599-605 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec26
599		604
600	class PostfixResolveNode : public PrePostResolveNode {	605	class PostfixResolveNode : public PrePostResolveNode {
601	public:	606	public:
602	PostfixResolveNode(int, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);	607	PostfixResolveNode(const JSTokenLocation&, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
603		608
604	private:	609	private:
605	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	610	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 609-615 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec27
609		614
610	class PostfixBracketNode : public ExpressionNode, public ThrowableSubExpressionData {	615	class PostfixBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
611	public:	616	public:
612	PostfixBracketNode(int, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);	617	PostfixBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
613		618
614	private:	619	private:
615	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	620	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 621-627 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec28
621		626
622	class PostfixDotNode : public ExpressionNode, public ThrowableSubExpressionData {	627	class PostfixDotNode : public ExpressionNode, public ThrowableSubExpressionData {
623	public:	628	public:
624	PostfixDotNode(int, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);	629	PostfixDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
625		630
626	private:	631	private:
627	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	632	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 633-639 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec29
633		638
634	class PostfixErrorNode : public ExpressionNode, public ThrowableSubExpressionData {	639	class PostfixErrorNode : public ExpressionNode, public ThrowableSubExpressionData {
635	public:	640	public:
636	PostfixErrorNode(int, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);	641	PostfixErrorNode(const JSTokenLocation&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
637		642
638	private:	643	private:
639	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	644	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 643-649 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec30
643		648
644	class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {	649	class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {
645	public:	650	public:
646	DeleteResolveNode(int, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);	651	DeleteResolveNode(const JSTokenLocation&, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
647		652
648	private:	653	private:
649	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	654	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 653-659 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec31
653		658
654	class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {	659	class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {
655	public:	660	public:
656	DeleteBracketNode(int, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset);	661	DeleteBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset);
657		662
658	private:	663	private:
659	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	664	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 664-670 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec32
664		669
665	class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {	670	class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {
666	public:	671	public:
667	DeleteDotNode(int, ExpressionNode* base, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);	672	DeleteDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
668		673
669	private:	674	private:
670	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	675	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 675-681 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec33
675		680
676	class DeleteValueNode : public ExpressionNode {	681	class DeleteValueNode : public ExpressionNode {
677	public:	682	public:
678	DeleteValueNode(int, ExpressionNode*);	683	DeleteValueNode(const JSTokenLocation&, ExpressionNode*);
679		684
680	private:	685	private:
681	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	686	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 685-691 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec34
685		690
686	class VoidNode : public ExpressionNode {	691	class VoidNode : public ExpressionNode {
687	public:	692	public:
688	VoidNode(int, ExpressionNode*);	693	VoidNode(const JSTokenLocation&, ExpressionNode*);
689		694
690	private:	695	private:
691	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	696	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 695-701 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec35
695		700
696	class TypeOfResolveNode : public ExpressionNode {	701	class TypeOfResolveNode : public ExpressionNode {
697	public:	702	public:
698	TypeOfResolveNode(int, const Identifier&);	703	TypeOfResolveNode(const JSTokenLocation&, const Identifier&);
699		704
700	const Identifier& identifier() const { return m_ident; }	705	const Identifier& identifier() const { return m_ident; }
701		706
Lines 707-713 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec36
707		712
708	class TypeOfValueNode : public ExpressionNode {	713	class TypeOfValueNode : public ExpressionNode {
709	public:	714	public:
710	TypeOfValueNode(int, ExpressionNode*);	715	TypeOfValueNode(const JSTokenLocation&, ExpressionNode*);
711		716
712	private:	717	private:
713	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	718	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 717-723 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec37
717		722
718	class PrefixResolveNode : public PrePostResolveNode {	723	class PrefixResolveNode : public PrePostResolveNode {
719	public:	724	public:
720	PrefixResolveNode(int, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);	725	PrefixResolveNode(const JSTokenLocation&, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
721		726
722	private:	727	private:
723	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	728	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 727-733 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec38
727		732
728	class PrefixBracketNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {	733	class PrefixBracketNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
729	public:	734	public:
730	PrefixBracketNode(int, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);	735	PrefixBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
731		736
732	private:	737	private:
733	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	738	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 739-745 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec39
739		744
740	class PrefixDotNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {	745	class PrefixDotNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
741	public:	746	public:
742	PrefixDotNode(int, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);	747	PrefixDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
743		748
744	private:	749	private:
745	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	750	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 751-757 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec40
751		756
752	class PrefixErrorNode : public ExpressionNode, public ThrowableExpressionData {	757	class PrefixErrorNode : public ExpressionNode, public ThrowableExpressionData {
753	public:	758	public:
754	PrefixErrorNode(int, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);	759	PrefixErrorNode(const JSTokenLocation&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
755		760
756	private:	761	private:
757	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	762	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 761-767 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec41
761		766
762	class UnaryOpNode : public ExpressionNode {	767	class UnaryOpNode : public ExpressionNode {
763	public:	768	public:
764	UnaryOpNode(int, ResultType, ExpressionNode*, OpcodeID);	769	UnaryOpNode(const JSTokenLocation&, ResultType, ExpressionNode*, OpcodeID);
765		770
766	protected:	771	protected:
767	ExpressionNode* expr() { return m_expr; }	772	ExpressionNode* expr() { return m_expr; }
Lines 778-784 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec42
778		783
779	class UnaryPlusNode : public UnaryOpNode {	784	class UnaryPlusNode : public UnaryOpNode {
780	public:	785	public:
781	UnaryPlusNode(int, ExpressionNode*);	786	UnaryPlusNode(const JSTokenLocation&, ExpressionNode*);
782		787
783	private:	788	private:
784	virtual ExpressionNode* stripUnaryPlus() { return expr(); }	789	virtual ExpressionNode* stripUnaryPlus() { return expr(); }
Lines 786-797 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec43
786		791
787	class NegateNode : public UnaryOpNode {	792	class NegateNode : public UnaryOpNode {
788	public:	793	public:
789	NegateNode(int, ExpressionNode*);	794	NegateNode(const JSTokenLocation&, ExpressionNode*);
790	};	795	};
791		796
792	class BitwiseNotNode : public ExpressionNode {	797	class BitwiseNotNode : public ExpressionNode {
793	public:	798	public:
794	BitwiseNotNode(int, ExpressionNode*);	799	BitwiseNotNode(const JSTokenLocation&, ExpressionNode*);
795		800
796	protected:	801	protected:
797	ExpressionNode* expr() { return m_expr; }	802	ExpressionNode* expr() { return m_expr; }
Lines 805-811 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec44
805		810
806	class LogicalNotNode : public UnaryOpNode {	811	class LogicalNotNode : public UnaryOpNode {
807	public:	812	public:
808	LogicalNotNode(int, ExpressionNode*);	813	LogicalNotNode(const JSTokenLocation&, ExpressionNode*);
809	private:	814	private:
810	void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, bool fallThroughMeansTrue);	815	void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, bool fallThroughMeansTrue);
811	virtual bool hasConditionContextCodegen() const { return expr()->hasConditionContextCodegen(); }	816	virtual bool hasConditionContextCodegen() const { return expr()->hasConditionContextCodegen(); }
Lines 813-820 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec45
813		818
814	class BinaryOpNode : public ExpressionNode {	819	class BinaryOpNode : public ExpressionNode {
815	public:	820	public:
816	BinaryOpNode(int, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);	821	BinaryOpNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
817	BinaryOpNode(int, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);	822	BinaryOpNode(const JSTokenLocation&, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
818		823
819	RegisterID* emitStrcat(BytecodeGenerator& generator, RegisterID* destination, RegisterID* lhs = 0, ReadModifyResolveNode* emitExpressionInfoForMe = 0);	824	RegisterID* emitStrcat(BytecodeGenerator& generator, RegisterID* destination, RegisterID* lhs = 0, ReadModifyResolveNode* emitExpressionInfoForMe = 0);
820		825
Lines 838-909 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec46
838		843
839	class MultNode : public BinaryOpNode {	844	class MultNode : public BinaryOpNode {
840	public:	845	public:
841	MultNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	846	MultNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
842	};	847	};
843		848
844	class DivNode : public BinaryOpNode {	849	class DivNode : public BinaryOpNode {
845	public:	850	public:
846	DivNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	851	DivNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
847	};	852	};
848		853
849	class ModNode : public BinaryOpNode {	854	class ModNode : public BinaryOpNode {
850	public:	855	public:
851	ModNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	856	ModNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
852	};	857	};
853		858
854	class AddNode : public BinaryOpNode {	859	class AddNode : public BinaryOpNode {
855	public:	860	public:
856	AddNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	861	AddNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
857		862
858	virtual bool isAdd() const { return true; }	863	virtual bool isAdd() const { return true; }
859	};	864	};
860		865
861	class SubNode : public BinaryOpNode {	866	class SubNode : public BinaryOpNode {
862	public:	867	public:
863	SubNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	868	SubNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
864		869
865	virtual bool isSubtract() const { return true; }	870	virtual bool isSubtract() const { return true; }
866	};	871	};
867		872
868	class LeftShiftNode : public BinaryOpNode {	873	class LeftShiftNode : public BinaryOpNode {
869	public:	874	public:
870	LeftShiftNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	875	LeftShiftNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
871	};	876	};
872		877
873	class RightShiftNode : public BinaryOpNode {	878	class RightShiftNode : public BinaryOpNode {
874	public:	879	public:
875	RightShiftNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	880	RightShiftNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
876	};	881	};
877		882
878	class UnsignedRightShiftNode : public BinaryOpNode {	883	class UnsignedRightShiftNode : public BinaryOpNode {
879	public:	884	public:
880	UnsignedRightShiftNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	885	UnsignedRightShiftNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
881	};	886	};
882		887
883	class LessNode : public BinaryOpNode {	888	class LessNode : public BinaryOpNode {
884	public:	889	public:
885	LessNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	890	LessNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
886	};	891	};
887		892
888	class GreaterNode : public BinaryOpNode {	893	class GreaterNode : public BinaryOpNode {
889	public:	894	public:
890	GreaterNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	895	GreaterNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
891	};	896	};
892		897
893	class LessEqNode : public BinaryOpNode {	898	class LessEqNode : public BinaryOpNode {
894	public:	899	public:
895	LessEqNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	900	LessEqNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
896	};	901	};
897		902
898	class GreaterEqNode : public BinaryOpNode {	903	class GreaterEqNode : public BinaryOpNode {
899	public:	904	public:
900	GreaterEqNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	905	GreaterEqNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
901	};	906	};
902		907
903	class ThrowableBinaryOpNode : public BinaryOpNode, public ThrowableExpressionData {	908	class ThrowableBinaryOpNode : public BinaryOpNode, public ThrowableExpressionData {
904	public:	909	public:
905	ThrowableBinaryOpNode(int, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);	910	ThrowableBinaryOpNode(const JSTokenLocation&, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
906	ThrowableBinaryOpNode(int, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);	911	ThrowableBinaryOpNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
907		912
908	private:	913	private:
909	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	914	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 911-917 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec47
911		916
912	class InstanceOfNode : public ThrowableBinaryOpNode {	917	class InstanceOfNode : public ThrowableBinaryOpNode {
913	public:	918	public:
914	InstanceOfNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	919	InstanceOfNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
915		920
916	private:	921	private:
917	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	922	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 919-930 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec48
919		924
920	class InNode : public ThrowableBinaryOpNode {	925	class InNode : public ThrowableBinaryOpNode {
921	public:	926	public:
922	InNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	927	InNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
923	};	928	};
924		929
925	class EqualNode : public BinaryOpNode {	930	class EqualNode : public BinaryOpNode {
926	public:	931	public:
927	EqualNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	932	EqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
928		933
929	private:	934	private:
930	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	935	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 932-943 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec49
932		937
933	class NotEqualNode : public BinaryOpNode {	938	class NotEqualNode : public BinaryOpNode {
934	public:	939	public:
935	NotEqualNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	940	NotEqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
936	};	941	};
937		942
938	class StrictEqualNode : public BinaryOpNode {	943	class StrictEqualNode : public BinaryOpNode {
939	public:	944	public:
940	StrictEqualNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	945	StrictEqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
941		946
942	private:	947	private:
943	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	948	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 945-972 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec50
945		950
946	class NotStrictEqualNode : public BinaryOpNode {	951	class NotStrictEqualNode : public BinaryOpNode {
947	public:	952	public:
948	NotStrictEqualNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	953	NotStrictEqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
949	};	954	};
950		955
951	class BitAndNode : public BinaryOpNode {	956	class BitAndNode : public BinaryOpNode {
952	public:	957	public:
953	BitAndNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	958	BitAndNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
954	};	959	};
955		960
956	class BitOrNode : public BinaryOpNode {	961	class BitOrNode : public BinaryOpNode {
957	public:	962	public:
958	BitOrNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	963	BitOrNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
959	};	964	};
960		965
961	class BitXOrNode : public BinaryOpNode {	966	class BitXOrNode : public BinaryOpNode {
962	public:	967	public:
963	BitXOrNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);	968	BitXOrNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
964	};	969	};
965		970
966	// m_expr1 && m_expr2, m_expr1 \|\| m_expr2	971	// m_expr1 && m_expr2, m_expr1 \|\| m_expr2
967	class LogicalOpNode : public ExpressionNode {	972	class LogicalOpNode : public ExpressionNode {
968	public:	973	public:
969	LogicalOpNode(int, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator);	974	LogicalOpNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator);
970		975
971	private:	976	private:
972	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	977	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 981-987 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec51
981	// The ternary operator, "m_logical ? m_expr1 : m_expr2"	986	// The ternary operator, "m_logical ? m_expr1 : m_expr2"
982	class ConditionalNode : public ExpressionNode {	987	class ConditionalNode : public ExpressionNode {
983	public:	988	public:
984	ConditionalNode(int, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2);	989	ConditionalNode(const JSTokenLocation&, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2);
985		990
986	private:	991	private:
987	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	992	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 993-999 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec52
993		998
994	class ReadModifyResolveNode : public ExpressionNode, public ThrowableExpressionData {	999	class ReadModifyResolveNode : public ExpressionNode, public ThrowableExpressionData {
995	public:	1000	public:
996	ReadModifyResolveNode(int, const Identifier&, Operator, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);	1001	ReadModifyResolveNode(const JSTokenLocation&, const Identifier&, Operator, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
997		1002
998	private:	1003	private:
999	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1004	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1006-1012 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec53
1006		1011
1007	class AssignResolveNode : public ExpressionNode, public ThrowableExpressionData {	1012	class AssignResolveNode : public ExpressionNode, public ThrowableExpressionData {
1008	public:	1013	public:
1009	AssignResolveNode(int, const Identifier&, ExpressionNode* right);	1014	AssignResolveNode(const JSTokenLocation&, const Identifier&, ExpressionNode* right);
1010		1015
1011	private:	1016	private:
1012	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1017	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1017-1023 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec54
1017		1022
1018	class ReadModifyBracketNode : public ExpressionNode, public ThrowableSubExpressionData {	1023	class ReadModifyBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
1019	public:	1024	public:
1020	ReadModifyBracketNode(int, ExpressionNode* base, ExpressionNode* subscript, Operator, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);	1025	ReadModifyBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, Operator, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
1021		1026
1022	private:	1027	private:
1023	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1028	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1032-1038 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec55
1032		1037
1033	class AssignBracketNode : public ExpressionNode, public ThrowableExpressionData {	1038	class AssignBracketNode : public ExpressionNode, public ThrowableExpressionData {
1034	public:	1039	public:
1035	AssignBracketNode(int, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);	1040	AssignBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
1036		1041
1037	private:	1042	private:
1038	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1043	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1046-1052 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec56
1046		1051
1047	class AssignDotNode : public ExpressionNode, public ThrowableExpressionData {	1052	class AssignDotNode : public ExpressionNode, public ThrowableExpressionData {
1048	public:	1053	public:
1049	AssignDotNode(int, ExpressionNode* base, const Identifier&, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);	1054	AssignDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
1050		1055
1051	private:	1056	private:
1052	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1057	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1059-1065 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec57
1059		1064
1060	class ReadModifyDotNode : public ExpressionNode, public ThrowableSubExpressionData {	1065	class ReadModifyDotNode : public ExpressionNode, public ThrowableSubExpressionData {
1061	public:	1066	public:
1062	ReadModifyDotNode(int, ExpressionNode* base, const Identifier&, Operator, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);	1067	ReadModifyDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, Operator, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
1063		1068
1064	private:	1069	private:
1065	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1070	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1073-1079 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec58
1073		1078
1074	class AssignErrorNode : public ExpressionNode, public ThrowableExpressionData {	1079	class AssignErrorNode : public ExpressionNode, public ThrowableExpressionData {
1075	public:	1080	public:
1076	AssignErrorNode(int, unsigned divot, unsigned startOffset, unsigned endOffset);	1081	AssignErrorNode(const JSTokenLocation&, unsigned divot, unsigned startOffset, unsigned endOffset);
1077		1082
1078	private:	1083	private:
1079	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1084	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1083-1089 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec59
1083		1088
1084	class CommaNode : public ExpressionNode, public ParserArenaDeletable {	1089	class CommaNode : public ExpressionNode, public ParserArenaDeletable {
1085	public:	1090	public:
1086	CommaNode(int, ExpressionNode* expr1, ExpressionNode* expr2);	1091	CommaNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2);
1087		1092
1088	using ParserArenaDeletable::operator new;	1093	using ParserArenaDeletable::operator new;
1089		1094
Lines 1098-1104 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec60
1098		1103
1099	class ConstDeclNode : public ExpressionNode {	1104	class ConstDeclNode : public ExpressionNode {
1100	public:	1105	public:
1101	ConstDeclNode(int, const Identifier&, ExpressionNode*);	1106	ConstDeclNode(const JSTokenLocation&, const Identifier&, ExpressionNode*);
1102		1107
1103	bool hasInitializer() const { return m_init; }	1108	bool hasInitializer() const { return m_init; }
1104	const Identifier& ident() { return m_ident; }	1109	const Identifier& ident() { return m_ident; }
Lines 1118-1124 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec61
1118		1123
1119	class ConstStatementNode : public StatementNode {	1124	class ConstStatementNode : public StatementNode {
1120	public:	1125	public:
1121	ConstStatementNode(int, ConstDeclNode* next);	1126	ConstStatementNode(const JSTokenLocation&, ConstDeclNode* next);
1122		1127
1123	private:	1128	private:
1124	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1129	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1143-1149 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec62
1143		1148
1144	class BlockNode : public StatementNode {	1149	class BlockNode : public StatementNode {
1145	public:	1150	public:
1146	BlockNode(int, SourceElements* = 0);	1151	BlockNode(const JSTokenLocation&, SourceElements* = 0);
1147		1152
1148	StatementNode* singleStatement() const;	1153	StatementNode* singleStatement() const;
1149	StatementNode* lastStatement() const;	1154	StatementNode* lastStatement() const;
Lines 1158-1164 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec63
1158		1163
1159	class EmptyStatementNode : public StatementNode {	1164	class EmptyStatementNode : public StatementNode {
1160	public:	1165	public:
1161	EmptyStatementNode(int);	1166	EmptyStatementNode(const JSTokenLocation&);
1162		1167
1163	private:	1168	private:
1164	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1169	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1168-1174 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec64
1168		1173
1169	class DebuggerStatementNode : public StatementNode {	1174	class DebuggerStatementNode : public StatementNode {
1170	public:	1175	public:
1171	DebuggerStatementNode(int);	1176	DebuggerStatementNode(const JSTokenLocation&);
1172		1177
1173	private:	1178	private:
1174	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1179	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1176-1182 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec65
1176		1181
1177	class ExprStatementNode : public StatementNode {	1182	class ExprStatementNode : public StatementNode {
1178	public:	1183	public:
1179	ExprStatementNode(int, ExpressionNode*);	1184	ExprStatementNode(const JSTokenLocation&, ExpressionNode*);
1180		1185
1181	ExpressionNode* expr() const { return m_expr; }	1186	ExpressionNode* expr() const { return m_expr; }
1182		1187
Lines 1190-1197 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec66
1190		1195
1191	class VarStatementNode : public StatementNode {	1196	class VarStatementNode : public StatementNode {
1192	public:	1197	public:
1193	VarStatementNode(int, ExpressionNode*);	1198	VarStatementNode(const JSTokenLocation&, ExpressionNode*);
1194
1195	private:	1199	private:
1196	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1200	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1197		1201
Lines 1200-1206 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec67
1200		1204
1201	class IfNode : public StatementNode {	1205	class IfNode : public StatementNode {
1202	public:	1206	public:
1203	IfNode(int, ExpressionNode* condition, StatementNode* ifBlock);	1207	IfNode(const JSTokenLocation&, ExpressionNode* condition, StatementNode* ifBlock);
1204		1208
1205	protected:	1209	protected:
1206	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1210	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1211-1217 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec68
1211		1215
1212	class IfElseNode : public IfNode {	1216	class IfElseNode : public IfNode {
1213	public:	1217	public:
1214	IfElseNode(int, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock);	1218	IfElseNode(const JSTokenLocation&, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock);
1215		1219
1216	private:	1220	private:
1217	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1221	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1221-1227 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec69
1221		1225
1222	class DoWhileNode : public StatementNode {	1226	class DoWhileNode : public StatementNode {
1223	public:	1227	public:
1224	DoWhileNode(int, StatementNode, ExpressionNode);	1228	DoWhileNode(const JSTokenLocation&, StatementNode, ExpressionNode);
1225		1229
1226	private:	1230	private:
1227	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1231	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1232-1238 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec70
1232		1236
1233	class WhileNode : public StatementNode {	1237	class WhileNode : public StatementNode {
1234	public:	1238	public:
1235	WhileNode(int, ExpressionNode, StatementNode);	1239	WhileNode(const JSTokenLocation&, ExpressionNode, StatementNode);
1236		1240
1237	private:	1241	private:
1238	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1242	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1243-1249 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec71
1243		1247
1244	class ForNode : public StatementNode {	1248	class ForNode : public StatementNode {
1245	public:	1249	public:
1246	ForNode(int, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode*);	1250	ForNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode*);
1247		1251
1248	private:	1252	private:
1249	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1253	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1256-1263 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec72
1256		1260
1257	class ForInNode : public StatementNode, public ThrowableExpressionData {	1261	class ForInNode : public StatementNode, public ThrowableExpressionData {
1258	public:	1262	public:
1259	ForInNode(int, ExpressionNode, ExpressionNode, StatementNode*);	1263	ForInNode(const JSTokenLocation&, ExpressionNode, ExpressionNode, StatementNode*);
1260	ForInNode(JSGlobalData, int, const Identifier&, ExpressionNode, ExpressionNode, StatementNode, int divot, int startOffset, int endOffset);	1264	ForInNode(JSGlobalData, const JSTokenLocation&, const Identifier&, ExpressionNode, ExpressionNode, StatementNode, int divot, int startOffset, int endOffset);
1261		1265
1262	private:	1266	private:
1263	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1267	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1271-1278 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec73
1271		1275
1272	class ContinueNode : public StatementNode, public ThrowableExpressionData {	1276	class ContinueNode : public StatementNode, public ThrowableExpressionData {
1273	public:	1277	public:
1274	ContinueNode(JSGlobalData*, int);	1278	ContinueNode(JSGlobalData*, const JSTokenLocation&);
1275	ContinueNode(int, const Identifier&);	1279	ContinueNode(const JSTokenLocation&, const Identifier&);
1276		1280
1277	private:	1281	private:
1278	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1282	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1282-1289 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec74
1282		1286
1283	class BreakNode : public StatementNode, public ThrowableExpressionData {	1287	class BreakNode : public StatementNode, public ThrowableExpressionData {
1284	public:	1288	public:
1285	BreakNode(JSGlobalData*, int);	1289	BreakNode(JSGlobalData*, const JSTokenLocation&);
1286	BreakNode(int, const Identifier&);	1290	BreakNode(const JSTokenLocation&, const Identifier&);
1287		1291
1288	private:	1292	private:
1289	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1293	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1293-1299 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec75
1293		1297
1294	class ReturnNode : public StatementNode, public ThrowableExpressionData {	1298	class ReturnNode : public StatementNode, public ThrowableExpressionData {
1295	public:	1299	public:
1296	ReturnNode(int, ExpressionNode* value);	1300	ReturnNode(const JSTokenLocation&, ExpressionNode* value);
1297		1301
1298	ExpressionNode* value() { return m_value; }	1302	ExpressionNode* value() { return m_value; }
1299		1303
Lines 1307-1313 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec76
1307		1311
1308	class WithNode : public StatementNode {	1312	class WithNode : public StatementNode {
1309	public:	1313	public:
1310	WithNode(int, ExpressionNode, StatementNode, uint32_t divot, uint32_t expressionLength);	1314	WithNode(const JSTokenLocation&, ExpressionNode, StatementNode, uint32_t divot, uint32_t expressionLength);
1311		1315
1312	private:	1316	private:
1313	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1317	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1320-1326 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec77
1320		1324
1321	class LabelNode : public StatementNode, public ThrowableExpressionData {	1325	class LabelNode : public StatementNode, public ThrowableExpressionData {
1322	public:	1326	public:
1323	LabelNode(int, const Identifier& name, StatementNode*);	1327	LabelNode(const JSTokenLocation&, const Identifier& name, StatementNode*);
1324		1328
1325	private:	1329	private:
1326	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1330	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1331-1337 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec78
1331		1335
1332	class ThrowNode : public StatementNode, public ThrowableExpressionData {	1336	class ThrowNode : public StatementNode, public ThrowableExpressionData {
1333	public:	1337	public:
1334	ThrowNode(int, ExpressionNode*);	1338	ThrowNode(const JSTokenLocation&, ExpressionNode*);
1335		1339
1336	private:	1340	private:
1337	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1341	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1341-1347 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec79
1341		1345
1342	class TryNode : public StatementNode {	1346	class TryNode : public StatementNode {
1343	public:	1347	public:
1344	TryNode(int, StatementNode* tryBlock, const Identifier& exceptionIdent, StatementNode* catchBlock, StatementNode* finallyBlock);	1348	TryNode(const JSTokenLocation&, StatementNode* tryBlock, const Identifier& exceptionIdent, StatementNode* catchBlock, StatementNode* finallyBlock);
1345		1349
1346	private:	1350	private:
1347	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1351	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
Lines 1370-1377 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec80
1370	typedef DeclarationStacks::VarStack VarStack;	1374	typedef DeclarationStacks::VarStack VarStack;
1371	typedef DeclarationStacks::FunctionStack FunctionStack;	1375	typedef DeclarationStacks::FunctionStack FunctionStack;
1372		1376
1373	ScopeNode(JSGlobalData*, int, bool inStrictContext);	1377	ScopeNode(JSGlobalData*, const JSTokenLocation&, bool inStrictContext);
1374	ScopeNode(JSGlobalData, int, const SourceCode&, SourceElements, VarStack, FunctionStack, IdentifierSet&, CodeFeatures, int numConstants);	1378	ScopeNode(JSGlobalData, const JSTokenLocation&, const SourceCode&, SourceElements, VarStack, FunctionStack, IdentifierSet&, CodeFeatures, int numConstants);
1375		1379
1376	using ParserArenaRefCounted::operator new;	1380	using ParserArenaRefCounted::operator new;
1377		1381
Lines 1433-1444 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec81
1433	class ProgramNode : public ScopeNode {	1437	class ProgramNode : public ScopeNode {
1434	public:	1438	public:
1435	static const bool isFunctionNode = false;	1439	static const bool isFunctionNode = false;
1436	static PassRefPtr<ProgramNode> create(JSGlobalData, int, SourceElements, VarStack, FunctionStack, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);	1440	static PassRefPtr<ProgramNode> create(JSGlobalData, const JSTokenLocation&, SourceElements, VarStack, FunctionStack, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1437		1441
1438	static const bool scopeIsFunction = false;	1442	static const bool scopeIsFunction = false;
1439		1443
1440	private:	1444	private:
1441	ProgramNode(JSGlobalData, int, SourceElements, VarStack, FunctionStack, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);	1445	ProgramNode(JSGlobalData, const JSTokenLocation&, SourceElements, VarStack, FunctionStack, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1442		1446
1443	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1447	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1444	};	1448	};
Lines 1446-1457 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec82
1446	class EvalNode : public ScopeNode {	1450	class EvalNode : public ScopeNode {
1447	public:	1451	public:
1448	static const bool isFunctionNode = false;	1452	static const bool isFunctionNode = false;
1449	static PassRefPtr<EvalNode> create(JSGlobalData, int, SourceElements, VarStack, FunctionStack, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);	1453	static PassRefPtr<EvalNode> create(JSGlobalData, const JSTokenLocation&, SourceElements, VarStack, FunctionStack, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1450		1454
1451	static const bool scopeIsFunction = false;	1455	static const bool scopeIsFunction = false;
1452		1456
1453	private:	1457	private:
1454	EvalNode(JSGlobalData, int, SourceElements, VarStack, FunctionStack, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);	1458	EvalNode(JSGlobalData, const JSTokenLocation&, SourceElements, VarStack, FunctionStack, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1455		1459
1456	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1460	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1457	};	1461	};
Lines 1468-1475 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec83
1468	class FunctionBodyNode : public ScopeNode {	1472	class FunctionBodyNode : public ScopeNode {
1469	public:	1473	public:
1470	static const bool isFunctionNode = true;	1474	static const bool isFunctionNode = true;
1471	static FunctionBodyNode* create(JSGlobalData*, int, bool isStrictMode);	1475	static FunctionBodyNode* create(JSGlobalData*, const JSTokenLocation&, bool isStrictMode);
1472	static PassRefPtr<FunctionBodyNode> create(JSGlobalData, int, SourceElements, VarStack, FunctionStack, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);	1476	static PassRefPtr<FunctionBodyNode> create(JSGlobalData, const JSTokenLocation&, SourceElements, VarStack, FunctionStack, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1473		1477
1474	FunctionParameters* parameters() const { return m_parameters.get(); }	1478	FunctionParameters* parameters() const { return m_parameters.get(); }
1475	size_t parameterCount() const { return m_parameters->size(); }	1479	size_t parameterCount() const { return m_parameters->size(); }
Lines 1486-1493 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec84
1486	static const bool scopeIsFunction = true;	1490	static const bool scopeIsFunction = true;
1487		1491
1488	private:	1492	private:
1489	FunctionBodyNode(JSGlobalData*, int, bool inStrictContext);	1493	FunctionBodyNode(JSGlobalData*, const JSTokenLocation&, bool inStrictContext);
1490	FunctionBodyNode(JSGlobalData, int, SourceElements, VarStack, FunctionStack, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);	1494	FunctionBodyNode(JSGlobalData, const JSTokenLocation&, SourceElements, VarStack, FunctionStack, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1491		1495
1492	Identifier m_ident;	1496	Identifier m_ident;
1493	Identifier m_inferredName;	1497	Identifier m_inferredName;
Lines 1496-1502 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec85
1496		1500
1497	class FuncExprNode : public ExpressionNode {	1501	class FuncExprNode : public ExpressionNode {
1498	public:	1502	public:
1499	FuncExprNode(int, const Identifier&, FunctionBodyNode, const SourceCode&, ParameterNode = 0);	1503	FuncExprNode(const JSTokenLocation&, const Identifier&, FunctionBodyNode, const SourceCode&, ParameterNode = 0);
1500		1504
1501	FunctionBodyNode* body() { return m_body; }	1505	FunctionBodyNode* body() { return m_body; }
1502		1506
Lines 1510-1516 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec86
1510		1514
1511	class FuncDeclNode : public StatementNode {	1515	class FuncDeclNode : public StatementNode {
1512	public:	1516	public:
1513	FuncDeclNode(int, const Identifier&, FunctionBodyNode, const SourceCode&, ParameterNode = 0);	1517	FuncDeclNode(const JSTokenLocation&, const Identifier&, FunctionBodyNode, const SourceCode&, ParameterNode = 0);
1514		1518
1515	FunctionBodyNode* body() { return m_body; }	1519	FunctionBodyNode* body() { return m_body; }
1516		1520
Lines 1561-1567 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec87
1561		1565
1562	class SwitchNode : public StatementNode {	1566	class SwitchNode : public StatementNode {
1563	public:	1567	public:
1564	SwitchNode(int, ExpressionNode, CaseBlockNode);	1568	SwitchNode(const JSTokenLocation&, ExpressionNode, CaseBlockNode);
1565		1569
1566	private:	1570	private:
1567	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);	1571	virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);



    bool seenNonDirective = false;
    const Identifier* directive = 0;
    unsigned directiveLiteralLength = 0;
    unsigned startOffset = m_token.m_location.startOffset;
    unsigned oldLastLineNumber = m_lexer->lastLineNumber();
    unsigned oldLineNumber = m_lexer->lineNumber();
    bool hasSetStrict = false;

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseVarDeclaration(TreeBuilder& context)
{
    ASSERT(match(VAR));
    JSTokenLocation location(tokenLocation());
    int start = tokenLine();
    int end = 0;
    int scratch;

    failIfTrue(m_error);
    failIfFalse(autoSemiColon());
    
    return context.createVarStatement(location, varDecls, start, end);
}

template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseConstDeclaration(TreeBuilder& context)
{
    ASSERT(match(CONSTTOKEN));
    JSTokenLocation location(tokenLocation());
    int start = tokenLine();
    int end = 0;
    TreeConstDeclList constDecls = parseConstDeclarationList(context);
    failIfTrue(m_error);
    failIfFalse(autoSemiColon());
    
    return context.createConstStatement(location, constDecls, start, end);
}

template <typename LexerType>

    endLoop();
    failIfFalse(statement);
    int endLine = tokenLine();
    JSTokenLocation location(tokenLocation());
    consumeOrFail(WHILE);
    consumeOrFail(OPENPAREN);
    TreeExpression expr = parseExpression(context);

    consumeOrFail(CLOSEPAREN);
    if (match(SEMICOLON))
        next(); // Always performs automatic semicolon insertion.
    return context.createDoWhileStatement(location, statement, expr, startLine, endLine);
}

template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseWhileStatement(TreeBuilder& context)
{
    ASSERT(match(WHILE));
    JSTokenLocation location(tokenLocation());
    int startLine = tokenLine();
    next();
    consumeOrFail(OPENPAREN);

    TreeStatement statement = parseStatement(context, unused);
    endLoop();
    failIfFalse(statement);
    return context.createWhileStatement(location, expr, statement, startLine, endLine);
}

template <typename LexerType>

    TreeExpression varDecls = 0;
    do {
        declarations++;
        JSTokenLocation location(tokenLocation());
        next();
        matchOrFail(IDENT);
        

            lastInitializer = initializer;
            failIfFalse(initializer);
            
            TreeExpression node = context.createAssignResolve(location, *name, initializer, varStart, varDivot, lastTokenEnd());
            if (!varDecls)
                varDecls = node;
            else
                varDecls = context.combineCommaNodes(location, varDecls, node);
        }
    } while (match(COMMA));
    return varDecls;

    TreeConstDeclList constDecls = 0;
    TreeConstDeclList tail = 0;
    do {
        JSTokenLocation location(tokenLocation());
        next();
        matchOrFail(IDENT);
        const Identifier* name = m_token.m_data.ident;

            next(TreeBuilder::DontBuildStrings); // consume '='
            initializer = parseAssignmentExpression(context);
        }
        tail = context.appendConstDecl(location, tail, name, initializer);
        if (!constDecls)
            constDecls = tail;
    } while (match(COMMA));

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseForStatement(TreeBuilder& context)
{
    ASSERT(match(FOR));
    JSTokenLocation location(tokenLocation());
    int startLine = tokenLine();
    next();
    consumeOrFail(OPENPAREN);

        endLoop();
        failIfFalse(statement);
        
        return context.createForInLoop(location, forInTarget, forInInitializer, expr, statement, declsStart, inLocation, exprEnd, initStart, initEnd, startLine, endLine);
    }
    
    if (!match(SEMICOLON)) {

        TreeStatement statement = parseStatement(context, unused);
        endLoop();
        failIfFalse(statement);
        return context.createForLoop(location, decls, condition, increment, statement, startLine, endLine);
    }
    
    // For-in loop

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

template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBreakStatement(TreeBuilder& context)
{
    ASSERT(match(BREAK));
    JSTokenLocation location(tokenLocation());
    int startCol = tokenStart();
    int endCol = tokenEnd();
    int startLine = tokenLine();

    
    if (autoSemiColon()) {
        failIfFalseWithMessage(breakIsValid(), "'break' is only valid inside a switch or loop statement");
        return context.createBreakStatement(location, startCol, endCol, startLine, endLine);
    }
    matchOrFail(IDENT);
    const Identifier* ident = m_token.m_data.ident;

    endLine = tokenLine();
    next();
    failIfFalse(autoSemiColon());
    return context.createBreakStatement(location, ident, startCol, endCol, startLine, endLine);
}

template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseContinueStatement(TreeBuilder& context)
{
    ASSERT(match(CONTINUE));
    JSTokenLocation location(tokenLocation());
    int startCol = tokenStart();
    int endCol = tokenEnd();
    int startLine = tokenLine();

    
    if (autoSemiColon()) {
        failIfFalseWithMessage(continueIsValid(), "'continue' is only valid inside a loop statement");
        return context.createContinueStatement(location, startCol, endCol, startLine, endLine);
    }
    matchOrFail(IDENT);
    const Identifier* ident = m_token.m_data.ident;

    endLine = tokenLine();
    next();
    failIfFalse(autoSemiColon());
    return context.createContinueStatement(location, ident, startCol, endCol, startLine, endLine);
}

template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseReturnStatement(TreeBuilder& context)
{
    ASSERT(match(RETURN));
    JSTokenLocation location(tokenLocation());
    failIfFalse(currentScope()->isFunction());
    int startLine = tokenLine();
    int endLine = startLine;

    if (match(SEMICOLON))
        endLine  = tokenLine();
    if (autoSemiColon())
        return context.createReturnStatement(location, 0, start, end, startLine, endLine);
    TreeExpression expr = parseExpression(context);
    failIfFalse(expr);
    end = lastTokenEnd();
    if (match(SEMICOLON))
        endLine  = tokenLine();
    failIfFalse(autoSemiColon());
    return context.createReturnStatement(location, expr, start, end, startLine, endLine);
}

template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseThrowStatement(TreeBuilder& context)
{
    ASSERT(match(THROW));
    JSTokenLocation location(tokenLocation());
    int eStart = tokenStart();
    int startLine = tokenLine();
    next();

    int endLine = tokenLine();
    failIfFalse(autoSemiColon());
    
    return context.createThrowStatement(location, expr, eStart, eEnd, startLine, endLine);
}

template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseWithStatement(TreeBuilder& context)
{
    ASSERT(match(WITH));
    JSTokenLocation location(tokenLocation());
    failIfTrueWithMessage(strictMode(), "'with' statements are not valid in strict mode");
    currentScope()->setNeedsFullActivation();
    int startLine = tokenLine();

    TreeStatement statement = parseStatement(context, unused);
    failIfFalse(statement);
    
    return context.createWithStatement(location, expr, statement, start, end, startLine, endLine);
}

template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseSwitchStatement(TreeBuilder& context)
{
    ASSERT(match(SWITCH));
    JSTokenLocation location(tokenLocation());
    int startLine = tokenLine();
    next();
    consumeOrFail(OPENPAREN);

    endSwitch();
    consumeOrFail(CLOSEBRACE);
    
    return context.createSwitchStatement(location, expr, firstClauses, defaultClause, secondClauses, startLine, endLine);
    
}


template <class TreeBuilder> TreeStatement Parser<LexerType>::parseTryStatement(TreeBuilder& context)
{
    ASSERT(match(TRY));
    JSTokenLocation location(tokenLocation());
    TreeStatement tryBlock = 0;
    const Identifier* ident = &m_globalData->propertyNames->nullIdentifier;
    TreeStatement catchBlock = 0;

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

template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseDebuggerStatement(TreeBuilder& context)
{
    ASSERT(match(DEBUGGER));
    JSTokenLocation location(tokenLocation());
    int startLine = tokenLine();
    int endLine = startLine;
    next();
    if (match(SEMICOLON))
        startLine = tokenLine();
    failIfFalse(autoSemiColon());
    return context.createDebugger(location, startLine, endLine);
}

template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBlockStatement(TreeBuilder& context)
{
    ASSERT(match(OPENBRACE));
    JSTokenLocation location(tokenLocation());
    int start = tokenLine();
    next();
    if (match(CLOSEBRACE)) {
        next();
        return context.createBlockStatement(location, 0, start, m_lastLine);
    }
    TreeSourceElements subtree = parseSourceElements<DontCheckForStrictMode>(context);
    failIfFalse(subtree);
    matchOrFail(CLOSEBRACE);
    next();
    return context.createBlockStatement(location, subtree, start, m_lastLine);
}

template <typename LexerType>

    case FUNCTION:
        failIfFalseIfStrictWithMessage(m_statementDepth == 1, "Functions cannot be declared in a nested block in strict mode");
        return parseFunctionDeclaration(context);
    case SEMICOLON: {
        JSTokenLocation location(tokenLocation());
        next();
        return context.createEmptyStatement(location);
    }
    case IF:
        return parseIfStatement(context);
    case DO:

    case STRING:
        directive = m_token.m_data.ident;
        if (directiveLiteralLength)
            *directiveLiteralLength = m_token.m_location.endOffset - m_token.m_location.startOffset;
        nonTrivialExpressionCount = m_nonTrivialExpressionCount;
    default:
        TreeStatement exprStatement = parseExpressionStatement(context);

template <class TreeBuilder> TreeFunctionBody Parser<LexerType>::parseFunctionBody(TreeBuilder& context)
{
    if (match(CLOSEBRACE))
        return context.createFunctionBody(tokenLocation(), strictMode());
    DepthManager statementDepth(&m_statementDepth);
    m_statementDepth = 0;
    typename TreeBuilder::FunctionBodyBuilder bodyBuilder(const_cast<JSGlobalData*>(m_globalData), m_lexer.get());
    failIfFalse(parseSourceElements<CheckForStrictMode>(bodyBuilder));
    return context.createFunctionBody(tokenLocation(), strictMode());
}

template <typename LexerType>

    
    openBracePos = m_token.m_data.intValue;
    bodyStartLine = tokenLine();
    JSTokenLocation location(tokenLocation());
    
    // If we know about this function already, we can use the cached info and skip the parser to the end of the function.
    if (const SourceProviderCacheItem* cachedInfo = TreeBuilder::CanUseFunctionCache ? findCachedFunctionInfo(openBracePos) : 0) {
        // If we're in a strict context, the cached function info must say it was strict too.
        ASSERT(!strictMode() || cachedInfo->strictMode);
        body = context.createFunctionBody(location, cachedInfo->strictMode);
        
        functionScope->restoreFunctionInfo(cachedInfo);
        failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo));
        
        closeBracePos = cachedInfo->closeBracePos;
        m_token = cachedInfo->closeBraceToken();
        m_lexer->setOffset(m_token.m_location.endOffset);
        m_lexer->setLineNumber(m_token.m_location.line);
        
        next();
        return true;

    OwnPtr<SourceProviderCacheItem> newInfo;
    int functionLength = closeBracePos - openBracePos;
    if (TreeBuilder::CanUseFunctionCache && m_functionCache && functionLength > minimumFunctionLengthToCache) {
        newInfo = adoptPtr(new SourceProviderCacheItem(m_token.m_location.line, closeBracePos));
        functionScope->saveFunctionInfo(newInfo.get());
    }
    

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseFunctionDeclaration(TreeBuilder& context)
{
    ASSERT(match(FUNCTION));
    JSTokenLocation location(tokenLocation());
    next();
    const Identifier* name = 0;
    TreeFormalParameterList parameters = 0;

    failIfFalse((parseFunctionInfo<FunctionNeedsName, true>(context, name, parameters, body, openBracePos, closeBracePos, bodyStartLine)));
    failIfFalse(name);
    failIfFalseIfStrict(declareVariable(name));
    return context.createFuncDeclStatement(location, name, body, parameters, openBracePos, closeBracePos, bodyStartLine, m_lastLine);
}

struct LabelInfo {

     * special case that looks for a colon as the next character in the input.
     */
    Vector<LabelInfo> labels;
    JSTokenLocation location;
    do {
        int start = tokenStart();
        int startLine = tokenLine();
        location = tokenLocation();
        if (!nextTokenIsColon()) {
            // If we hit this path we're making a expression statement, which
            // by definition can't make use of continue/break so we can just

            TreeExpression expression = parseExpression(context);
            failIfFalse(expression);
            failIfFalse(autoSemiColon());
            return context.createExprStatement(location, expression, startLine, m_lastLine);
        }
        const Identifier* ident = m_token.m_data.ident;
        int end = tokenEnd();

    failIfFalse(statement);
    for (size_t i = 0; i < labels.size(); i++) {
        const LabelInfo& info = labels[labels.size() - i - 1];
        statement = context.createLabelStatement(location, info.m_ident, statement, info.m_start, info.m_end);
    }
    return statement;
}

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionStatement(TreeBuilder& context)
{
    int startLine = tokenLine();
    JSTokenLocation location(tokenLocation());
    TreeExpression expression = parseExpression(context);
    failIfFalse(expression);
    failIfFalse(autoSemiColon());
    return context.createExprStatement(location, expression, startLine, m_lastLine);
}

template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseIfStatement(TreeBuilder& context)
{
    ASSERT(match(IF));
    JSTokenLocation ifLocation(tokenLocation());
    int start = tokenLine();
    next();
    

    failIfFalse(trueBlock);
    
    if (!match(ELSE))
        return context.createIfStatement(ifLocation, condition, trueBlock, start, end);
    
    Vector<TreeExpression> exprStack;
    Vector<pair<int, int> > posStack;
    Vector<JSTokenLocation> tokenLocationStack;
    Vector<TreeStatement> statementStack;
    bool trailingElse = false;
    do {
        tokenLocationStack.append(tokenLocation());
        next();
        if (!match(IF)) {
            const Identifier* unused = 0;

        posStack.append(make_pair(innerStart, innerEnd));
        statementStack.append(innerTrueBlock);
    } while (match(ELSE));

    if (!trailingElse) {
        TreeExpression condition = exprStack.last();
        exprStack.removeLast();

        statementStack.removeLast();
        pair<int, int> pos = posStack.last();
        posStack.removeLast();
        JSTokenLocation elseLocation = tokenLocationStack.last();
        tokenLocationStack.removeLast();
        statementStack.append(context.createIfStatement(elseLocation, condition, trueBlock, pos.first, pos.second));
    }
    
    while (!exprStack.isEmpty()) {

        statementStack.removeLast();
        pair<int, int> pos = posStack.last();
        posStack.removeLast();
        JSTokenLocation elseLocation = tokenLocationStack.last();
        tokenLocationStack.removeLast();
        statementStack.append(context.createIfStatement(elseLocation, condition, trueBlock, falseBlock, pos.first, pos.second));
    }
    
    return context.createIfStatement(ifLocation, condition, trueBlock, statementStack.last(), start, end);
}

template <typename LexerType>
template <class TreeBuilder> TreeExpression Parser<LexerType>::parseExpression(TreeBuilder& context)
{
    failIfStackOverflow();
    JSTokenLocation location(tokenLocation());
    TreeExpression node = parseAssignmentExpression(context);
    failIfFalse(node);
    if (!match(COMMA))

    m_nonLHSCount++;
    TreeExpression right = parseAssignmentExpression(context);
    failIfFalse(right);
    typename TreeBuilder::Comma commaNode = context.createCommaExpr(location, node, right);
    while (match(COMMA)) {
        next(TreeBuilder::DontBuildStrings);
        right = parseAssignmentExpression(context);

{
    failIfStackOverflow();
    int start = tokenStart();
    JSTokenLocation location(tokenLocation());
    int initialAssignmentCount = m_assignmentCount;
    int initialNonLHSCount = m_nonLHSCount;
    TreeExpression lhs = parseConditionalExpression(context);

        return lhs;
    
    while (assignmentStack)
        lhs = context.createAssignment(location, assignmentStack, lhs, initialAssignmentCount, m_assignmentCount, lastTokenEnd());
    
    return lhs;
}

template <typename LexerType>
template <class TreeBuilder> TreeExpression Parser<LexerType>::parseConditionalExpression(TreeBuilder& context)
{
    JSTokenLocation location(tokenLocation());
    TreeExpression cond = parseBinaryExpression(context);
    failIfFalse(cond);
    if (!match(QUESTION))

    
    TreeExpression rhs = parseAssignmentExpression(context);
    failIfFalse(rhs);
    return context.createConditionalExpr(location, cond, lhs, rhs);
}

ALWAYS_INLINE static bool isUnaryOp(JSTokenType token)

    int operandStackDepth = 0;
    int operatorStackDepth = 0;
    typename TreeBuilder::BinaryExprContext binaryExprContext(context);
    JSTokenLocation location(tokenLocation());
    while (true) {
        int exprStart = tokenStart();
        int initialAssignments = m_assignmentCount;

            typename TreeBuilder::BinaryOperand rhs = context.getFromOperandStack(-1);
            typename TreeBuilder::BinaryOperand lhs = context.getFromOperandStack(-2);
            context.shrinkOperandStackBy(operandStackDepth, 2);
            context.appendBinaryOperation(location, operandStackDepth, operatorStackDepth, lhs, rhs);
            context.operatorStackPop(operatorStackDepth);
        }
        context.operatorStackAppend(operatorStackDepth, operatorToken, precedence);

        typename TreeBuilder::BinaryOperand rhs = context.getFromOperandStack(-1);
        typename TreeBuilder::BinaryOperand lhs = context.getFromOperandStack(-2);
        context.shrinkOperandStackBy(operandStackDepth, 2);
        context.appendBinaryOperation(location, operandStackDepth, operatorStackDepth, lhs, rhs);
        context.operatorStackPop(operatorStackDepth);
    }
    return context.popOperandStack(operandStackDepth);

            numericPropertyName = m_token.m_data.doubleValue;
        else
            fail();
        JSTokenLocation location(tokenLocation());
        next();
        failIfFalse((parseFunctionInfo<FunctionNoRequirements, false>(context, accessorName, parameters, body, openBracePos, closeBracePos, bodyStartLine)));
        if (stringPropertyName)
            return context.template createGetterOrSetterProperty<complete>(location, type, stringPropertyName, parameters, body, openBracePos, closeBracePos, bodyStartLine, m_lastLine);
        return context.template createGetterOrSetterProperty<complete>(const_cast<JSGlobalData*>(m_globalData), location, type, numericPropertyName, parameters, body, openBracePos, closeBracePos, bodyStartLine, m_lastLine);
    }
    case NUMBER: {
        double propertyName = m_token.m_data.doubleValue;

    unsigned oldLastLineNumber = m_lexer->lastLineNumber();
    unsigned oldLineNumber = m_lexer->lineNumber();
    consumeOrFailWithFlags(OPENBRACE, TreeBuilder::DontBuildStrings);
    JSTokenLocation location(tokenLocation());

    int oldNonLHSCount = m_nonLHSCount;
    
    if (match(CLOSEBRACE)) {
        next();
        return context.createObjectLiteral(location);
    }
    
    TreeProperty property = parseProperty<false>(context);

        m_lexer->setLineNumber(oldLineNumber);
        return parseStrictObjectLiteral(context);
    }
    TreePropertyList propertyList = context.createPropertyList(location, property);
    TreePropertyList tail = propertyList;
    while (match(COMMA)) {
        next(TreeBuilder::DontBuildStrings);
        // allow extra comma, see http://bugs.webkit.org/show_bug.cgi?id=5939
        if (match(CLOSEBRACE))
            break;
        JSTokenLocation propertyLocation(tokenLocation());
        property = parseProperty<false>(context);
        failIfFalse(property);
        if (!m_syntaxAlreadyValidated && context.getType(property) != PropertyNode::Constant) {

            m_lexer->setLineNumber(oldLineNumber);
            return parseStrictObjectLiteral(context);
        }
        tail = context.createPropertyList(propertyLocation, property, tail);
    }

    location = tokenLocation();
    consumeOrFail(CLOSEBRACE);
    
    m_nonLHSCount = oldNonLHSCount;
    
    return context.createObjectLiteral(location, propertyList);
}

template <typename LexerType>

    
    int oldNonLHSCount = m_nonLHSCount;

    JSTokenLocation location(tokenLocation());    
    if (match(CLOSEBRACE)) {
        next();
        return context.createObjectLiteral(location);
    }
    
    TreeProperty property = parseProperty<true>(context);

    if (!m_syntaxAlreadyValidated)
        objectValidator.add(context.getName(property).impl(), context.getType(property));
    
    TreePropertyList propertyList = context.createPropertyList(location, property);
    TreePropertyList tail = propertyList;
    while (match(COMMA)) {
        next();
        // allow extra comma, see http://bugs.webkit.org/show_bug.cgi?id=5939
        if (match(CLOSEBRACE))
            break;
        JSTokenLocation propertyLocation(tokenLocation());
        property = parseProperty<true>(context);
        failIfFalse(property);
        if (!m_syntaxAlreadyValidated) {

                propertyEntry.iterator->second |= context.getType(property);
            }
        }
        tail = context.createPropertyList(propertyLocation, property, tail);
    }

    location = tokenLocation();
    consumeOrFail(CLOSEBRACE);

    m_nonLHSCount = oldNonLHSCount;

    return context.createObjectLiteral(location, propertyList);
}

template <typename LexerType>

        elisions++;
    }
    if (match(CLOSEBRACKET)) {
        JSTokenLocation location(tokenLocation());
        next(TreeBuilder::DontBuildStrings);
        return context.createArray(location, elisions);
    }
    
    TreeExpression elem = parseAssignmentExpression(context);

        }
        
        if (match(CLOSEBRACKET)) {
            JSTokenLocation location(tokenLocation());
            next(TreeBuilder::DontBuildStrings);
            return context.createArray(location, elisions, elementList);
        }
        TreeExpression elem = parseAssignmentExpression(context);
        failIfFalse(elem);
        tail = context.createElementList(tail, elisions, elem);
    }

    JSTokenLocation location(tokenLocation());
    consumeOrFail(CLOSEBRACKET);
    
    m_nonLHSCount = oldNonLHSCount;
    
    return context.createArray(location, elementList);
}

template <typename LexerType>

        return result;
    }
    case THISTOKEN: {
        JSTokenLocation location(tokenLocation());
        next();
        return context.thisExpr(location);
    }
    case IDENT: {
        int start = tokenStart();
        const Identifier* ident = m_token.m_data.ident;
        JSTokenLocation location(tokenLocation());
        next();
        currentScope()->useVariable(ident, m_globalData->propertyNames->eval == *ident);
        m_lastIdentifier = ident;
        return context.createResolve(location, ident, start);
    }
    case STRING: {
        const Identifier* ident = m_token.m_data.ident;
        JSTokenLocation location(tokenLocation());
        next();
        return context.createString(location, ident);
    }
    case NUMBER: {
        double d = m_token.m_data.doubleValue;
        JSTokenLocation location(tokenLocation());
        next();
        return context.createNumberExpr(location, d);
    }
    case NULLTOKEN: {
        JSTokenLocation location(tokenLocation());
        next();
        return context.createNull(location);
    }
    case TRUETOKEN: {
        JSTokenLocation location(tokenLocation());
        next();
        return context.createBoolean(location, true);
    }
    case FALSETOKEN: {
        JSTokenLocation location(tokenLocation());
        next();
        return context.createBoolean(location, false);
    }
    case DIVEQUAL:
    case DIVIDE: {

            failIfFalse(m_lexer->scanRegExp(pattern, flags));
        
        int start = tokenStart();
        JSTokenLocation location(tokenLocation());
        next();
        TreeExpression re = context.createRegExp(location, *pattern, *flags, start);
        if (!re) {
            const char* yarrErrorMsg = Yarr::checkSyntax(pattern->ustring());
            ASSERT(!m_errorMessage.isNull());

template <class TreeBuilder> TreeArguments Parser<LexerType>::parseArguments(TreeBuilder& context)
{
    consumeOrFailWithFlags(OPENPAREN, TreeBuilder::DontBuildStrings);
    JSTokenLocation location(tokenLocation());
    if (match(CLOSEPAREN)) {
        next(TreeBuilder::DontBuildStrings);
        return context.createArguments();

    TreeExpression firstArg = parseAssignmentExpression(context);
    failIfFalse(firstArg);
    
    TreeArgumentsList argList = context.createArgumentsList(location, firstArg);
    TreeArgumentsList tail = argList;
    while (match(COMMA)) {
        JSTokenLocation argumentLocation(tokenLocation());
        next(TreeBuilder::DontBuildStrings);
        TreeExpression arg = parseAssignmentExpression(context);
        failIfFalse(arg);
        tail = context.createArgumentsList(argumentLocation, tail, arg);
    }
    consumeOrFail(CLOSEPAREN);
    return context.createArguments(argList);

    int start = tokenStart();
    int expressionStart = start;
    int newCount = 0;
    JSTokenLocation location;
    while (match(NEW)) {
        next();
        newCount++;

        int openBracePos = 0;
        int closeBracePos = 0;
        int bodyStartLine = 0;
        location = tokenLocation();
        next();
        failIfFalse((parseFunctionInfo<FunctionNoRequirements, false>(context, name, parameters, body, openBracePos, closeBracePos, bodyStartLine)));
        base = context.createFunctionExpr(location, name, body, parameters, openBracePos, closeBracePos, bodyStartLine, m_lastLine);
    } else
        base = parsePrimaryExpression(context);
    
    failIfFalse(base);
    while (true) {
        location = tokenLocation();
        switch (m_token.m_type) {
        case OPENBRACKET: {
            m_nonTrivialExpressionCount++;

            int initialAssignments = m_assignmentCount;
            TreeExpression property = parseExpression(context);
            failIfFalse(property);
            base = context.createBracketAccess(location, base, property, initialAssignments != m_assignmentCount, expressionStart, expressionEnd, tokenEnd());
            consumeOrFail(CLOSEBRACKET);
            m_nonLHSCount = nonLHSCount;
            break;

                int exprEnd = lastTokenEnd();
                TreeArguments arguments = parseArguments(context);
                failIfFalse(arguments);
                base = context.createNewExpr(location, base, arguments, start, exprEnd, lastTokenEnd());
            } else {
                int expressionEnd = lastTokenEnd();
                TreeArguments arguments = parseArguments(context);
                failIfFalse(arguments);
                base = context.makeFunctionCallNode(location, base, arguments, expressionStart, expressionEnd, lastTokenEnd());
            }
            m_nonLHSCount = nonLHSCount;
            break;

            int expressionEnd = lastTokenEnd();
            nextExpectIdentifier(LexerFlagsIgnoreReservedWords | TreeBuilder::DontBuildKeywords);
            matchOrFail(IDENT);
            base = context.createDotAccess(location, base, m_token.m_data.ident, expressionStart, expressionEnd, tokenEnd());
            next();
            break;
        }

    }
endMemberExpression:
    while (newCount--)
        base = context.createNewExpr(location, base, start, lastTokenEnd());
    return base;
}


        m_nonTrivialExpressionCount++;
    }
    int subExprStart = tokenStart();
    JSTokenLocation location(tokenLocation());
    TreeExpression expr = parseMemberExpression(context);
    failIfFalse(expr);
    bool isEvalOrArguments = false;

    case PLUSPLUS:
        m_nonTrivialExpressionCount++;
        m_nonLHSCount++;
        expr = context.makePostfixNode(location, expr, OpPlusPlus, subExprStart, lastTokenEnd(), tokenEnd());
        m_assignmentCount++;
        failIfTrueIfStrictWithNameAndMessage(isEvalOrArguments, "'", m_lastIdentifier->impl(), "' cannot be modified in strict mode");
        failIfTrueIfStrict(requiresLExpr);

    case MINUSMINUS:
        m_nonTrivialExpressionCount++;
        m_nonLHSCount++;
        expr = context.makePostfixNode(location, expr, OpMinusMinus, subExprStart, lastTokenEnd(), tokenEnd());
        m_assignmentCount++;
        failIfTrueIfStrictWithNameAndMessage(isEvalOrArguments, "'", m_lastIdentifier->impl(), "' cannot be modified in strict mode");
        failIfTrueIfStrict(requiresLExpr);

    
    if (!TreeBuilder::CreatesAST && (m_syntaxAlreadyValidated || !strictMode()))
        return expr;

    location = tokenLocation();
    location.line = m_lexer->lastLineNumber();
    while (tokenStackDepth) {
        switch (context.unaryTokenStackLastType(tokenStackDepth)) {
        case EXCLAMATION:
            expr = context.createLogicalNot(location, expr);
            break;
        case TILDE:
            expr = context.makeBitwiseNotNode(location, expr);
            break;
        case MINUS:
            expr = context.makeNegateNode(location, expr);
            break;
        case PLUS:
            expr = context.createUnaryPlus(location, expr);
            break;
        case PLUSPLUS:
        case AUTOPLUSPLUS:
            expr = context.makePrefixNode(location, expr, OpPlusPlus, context.unaryTokenStackLastStart(tokenStackDepth), subExprStart + 1, end);
            m_assignmentCount++;
            break;
        case MINUSMINUS:
        case AUTOMINUSMINUS:
            expr = context.makePrefixNode(location, expr, OpMinusMinus, context.unaryTokenStackLastStart(tokenStackDepth), subExprStart + 1, end);
            m_assignmentCount++;
            break;
        case TYPEOF:
            expr = context.makeTypeOfNode(location, expr);
            break;
        case VOIDTOKEN:
            expr = context.createVoid(location, expr);
            break;
        case DELETETOKEN:
            failIfTrueIfStrictWithNameAndMessage(context.isResolve(expr), "Cannot delete unqualified property", m_lastIdentifier->impl(), "in strict mode");
            expr = context.makeDeleteNode(location, expr, context.unaryTokenStackLastStart(tokenStackDepth), end, end);
            break;
        default:
            // If we get here something has gone horribly horribly wrong




    ALWAYS_INLINE void next(unsigned lexerFlags = 0)
    {
        m_lastLine = m_token.m_location.line;
        m_lastTokenEnd = m_token.m_location.endOffset;
        m_lexer->setLastLineNumber(m_lastLine);
        m_token.m_type = m_lexer->lex(&m_token.m_data, &m_token.m_location, lexerFlags, strictMode());
    }

    ALWAYS_INLINE void nextExpectIdentifier(unsigned lexerFlags = 0)
    {
        m_lastLine = m_token.m_location.line;
        m_lastTokenEnd = m_token.m_location.endOffset;
        m_lexer->setLastLineNumber(m_lastLine);
        m_token.m_type = m_lexer->lexExpectIdentifier(&m_token.m_data, &m_token.m_location, lexerFlags, strictMode());
    }

    ALWAYS_INLINE bool nextTokenIsColon()

    
    ALWAYS_INLINE int tokenStart()
    {
        return m_token.m_location.startOffset;
    }
    
    ALWAYS_INLINE int tokenLine()
    {
        return m_token.m_location.line;
    }
    
    ALWAYS_INLINE int tokenEnd()
    {
        return m_token.m_location.endOffset;
    }
    
    ALWAYS_INLINE const JSTokenLocation& tokenLocation()
    {
        return m_token.m_location;
    }

    const char* getTokenName(JSTokenType tok)
    {
        switch (tok) {
        case NULLTOKEN: 


    RefPtr<ParsedNode> result;
    if (m_sourceElements) {
        JSTokenLocation location;
        location.line = m_lexer->lastLineNumber();
        location.column = m_lexer->currentColumnNumber();
        result = ParsedNode::create(&lexicalGlobalObject->globalData(),
                                    location,
                                    m_sourceElements,
                                    m_varDeclarations ? &m_varDeclarations->data : 0,
                                    m_funcDeclarations ? &m_funcDeclarations->data : 0,

                                    *m_source,
                                    m_features,
                                    m_numConstants);
        result->setLoc(m_source->firstLine(), m_lastLine, m_lexer->currentColumnNumber());
    } else if (lexicalGlobalObject) {
        // We can never see a syntax error when reparsing a function, since we should have
        // reported the error when parsing the containing program or eval code. So if we're



    const Identifier* ident;
};

struct JSTokenLocation {
    JSTokenLocation() : line(0), column(0) { }
    JSTokenLocation(const JSTokenLocation& location)
    {
        line = location.line;
        startOffset = location.startOffset;
        endOffset = location.endOffset;
        column = location.column;
    }
    int line;
    int startOffset;
    int endOffset;
    int column;
};

struct JSToken {
    JSTokenType m_type;
    JSTokenData m_data;
    JSTokenLocation m_location;
};

enum JSParserStrictness { JSParseNormal, JSParseStrict };



        JSToken token;
        token.m_type = CLOSEBRACE;
        token.m_data.intValue = closeBracePos;
        token.m_location.startOffset = closeBracePos;
        token.m_location.endOffset = closeBracePos + 1;
        token.m_location.line = closeBraceLine; 
        return token;
    }
    



    static const unsigned DontBuildStrings = LexerFlagsDontBuildStrings;

    int createSourceElements() { return 1; }
    ExpressionType makeFunctionCallNode(const JSTokenLocation&, int, int, int, int, int) { return CallExpr; }
    void appendToComma(ExpressionType& base, ExpressionType right) { base = right; }
    ExpressionType createCommaExpr(const JSTokenLocation&, ExpressionType, ExpressionType right) { return right; }
    ExpressionType makeAssignNode(const JSTokenLocation&, ExpressionType, Operator, ExpressionType, bool, bool, int, int, int) { return AssignmentExpr; }
    ExpressionType makePrefixNode(const JSTokenLocation&, ExpressionType, Operator, int, int, int) { return PreExpr; }
    ExpressionType makePostfixNode(const JSTokenLocation&, ExpressionType, Operator, int, int, int) { return PostExpr; }
    ExpressionType makeTypeOfNode(const JSTokenLocation&, ExpressionType) { return TypeofExpr; }
    ExpressionType makeDeleteNode(const JSTokenLocation&, ExpressionType, int, int, int) { return DeleteExpr; }
    ExpressionType makeNegateNode(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
    ExpressionType makeBitwiseNotNode(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
    ExpressionType createLogicalNot(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
    ExpressionType createUnaryPlus(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
    ExpressionType createVoid(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
    ExpressionType thisExpr(const JSTokenLocation&) { return ThisExpr; }
    ExpressionType createResolve(const JSTokenLocation&, const Identifier*, int) { return ResolveExpr; }
    ExpressionType createObjectLiteral(const JSTokenLocation&) { return ObjectLiteralExpr; }
    ExpressionType createObjectLiteral(const JSTokenLocation&, int) { return ObjectLiteralExpr; }
    ExpressionType createArray(const JSTokenLocation&, int) { return ArrayLiteralExpr; }
    ExpressionType createArray(const JSTokenLocation&, int, int) { return ArrayLiteralExpr; }
    ExpressionType createNumberExpr(const JSTokenLocation&, double) { return NumberExpr; }
    ExpressionType createString(const JSTokenLocation&, const Identifier*) { return StringExpr; }
    ExpressionType createBoolean(const JSTokenLocation&, bool) { return BoolExpr; }
    ExpressionType createNull(const JSTokenLocation&) { return NullExpr; }
    ExpressionType createBracketAccess(const JSTokenLocation&, ExpressionType, ExpressionType, bool, int, int, int) { return BracketExpr; }
    ExpressionType createDotAccess(const JSTokenLocation&, ExpressionType, const Identifier*, int, int, int) { return DotExpr; }
    ExpressionType createRegExp(const JSTokenLocation&, const Identifier& pattern, const Identifier&, int) { return Yarr::checkSyntax(pattern.ustring()) ? 0 : RegExpExpr; }
    ExpressionType createNewExpr(const JSTokenLocation&, ExpressionType, int, int, int, int) { return NewExpr; }
    ExpressionType createNewExpr(const JSTokenLocation&, ExpressionType, int, int) { return NewExpr; }
    ExpressionType createConditionalExpr(const JSTokenLocation&, ExpressionType, ExpressionType, ExpressionType) { return ConditionalExpr; }
    ExpressionType createAssignResolve(const JSTokenLocation&, const Identifier&, ExpressionType, int, int, int) { return AssignmentExpr; }
    ExpressionType createFunctionExpr(const JSTokenLocation&, const Identifier*, int, int, int, int, int, int) { return FunctionExpr; }
    int createFunctionBody(const JSTokenLocation&, bool) { return 1; }
    int createArguments() { return 1; }
    int createArguments(int) { return 1; }
    int createArgumentsList(const JSTokenLocation&, int) { return 1; }
    int createArgumentsList(const JSTokenLocation&, int, int) { return 1; }
    template <bool complete> Property createProperty(const Identifier* name, int, PropertyNode::Type type)
    {
        if (!complete)

            return Property(type);
        return Property(&globalData->parserArena->identifierArena().makeNumericIdentifier(globalData, name), type);
    }
    int createPropertyList(const JSTokenLocation&, Property) { return 1; }
    int createPropertyList(const JSTokenLocation&, Property, int) { return 1; }
    int createElementList(int, int) { return 1; }
    int createElementList(int, int, int) { return 1; }
    int createFormalParameterList(const Identifier&) { return 1; }

    int createClauseList(int) { return 1; }
    int createClauseList(int, int) { return 1; }
    void setUsesArguments(int) { }
    int createFuncDeclStatement(const JSTokenLocation&, const Identifier*, int, int, int, int, int, int) { return 1; }
    int createBlockStatement(const JSTokenLocation&, int, int, int) { return 1; }
    int createExprStatement(const JSTokenLocation&, int, int, int) { return 1; }
    int createIfStatement(const JSTokenLocation&, int, int, int, int) { return 1; }
    int createIfStatement(const JSTokenLocation&, int, int, int, int, int) { return 1; }
    int createForLoop(const JSTokenLocation&, int, int, int, int, int, int) { return 1; }
    int createForInLoop(const JSTokenLocation&, const Identifier*, int, int, int, int, int, int, int, int, int, int) { return 1; }
    int createForInLoop(const JSTokenLocation&, int, int, int, int, int, int, int, int) { return 1; }
    int createEmptyStatement(const JSTokenLocation&) { return 1; }
    int createVarStatement(const JSTokenLocation&, int, int, int) { return 1; }
    int createReturnStatement(const JSTokenLocation&, int, int, int, int, int) { return 1; }
    int createBreakStatement(const JSTokenLocation&, int, int, int, int) { return 1; }
    int createBreakStatement(const JSTokenLocation&, const Identifier*, int, int, int, int) { return 1; }
    int createContinueStatement(const JSTokenLocation&, int, int, int, int) { return 1; }
    int createContinueStatement(const JSTokenLocation&, const Identifier*, int, int, int, int) { return 1; }
    int createTryStatement(const JSTokenLocation&, int, const Identifier*, int, int, int, int) { return 1; }
    int createSwitchStatement(const JSTokenLocation&, int, int, int, int, int, int) { return 1; }
    int createWhileStatement(const JSTokenLocation&, int, int, int, int) { return 1; }
    int createWithStatement(const JSTokenLocation&, int, int, int, int, int, int) { return 1; }
    int createDoWhileStatement(const JSTokenLocation&, int, int, int, int) { return 1; }
    int createLabelStatement(const JSTokenLocation&, const Identifier*, int, int, int) { return 1; }
    int createThrowStatement(const JSTokenLocation&, int, int, int, int, int) { return 1; }
    int createDebugger(const JSTokenLocation&, int, int) { return 1; }
    int createConstStatement(const JSTokenLocation&, int, int, int) { return 1; }
    int appendConstDecl(const JSTokenLocation&, int, const Identifier*, int) { return 1; }
    template <bool strict> Property createGetterOrSetterProperty(const JSTokenLocation&, PropertyNode::Type type, const Identifier* name, int, int, int, int, int, int)
    {
        ASSERT(name);
        if (!strict)
            return Property(type);
        return Property(name, type);
    }
    template <bool strict> Property createGetterOrSetterProperty(JSGlobalData* globalData, const JSTokenLocation&, PropertyNode::Type type, double name, int, int, int, int, int, int)
    {
        if (!strict)
            return Property(type);


    void appendStatement(int, int) { }
    void addVar(const Identifier*, bool) { }
    int combineCommaNodes(const JSTokenLocation&, int, int) { return 1; }
    int evalCount() const { return 0; }
    void appendBinaryExpressionInfo(int& operandStackDepth, int expr, int, int, int, bool)
    {

    bool operatorStackHasHigherPrecedence(int&, int) { return true; }
    BinaryOperand getFromOperandStack(int) { return m_topBinaryExpr; }
    void shrinkOperandStackBy(int& operandStackDepth, int amount) { operandStackDepth -= amount; }
    void appendBinaryOperation(const JSTokenLocation&, int& operandStackDepth, int&, BinaryOperand, BinaryOperand) { operandStackDepth++; }
    void operatorStackAppend(int& operatorStackDepth, int, int) { operatorStackDepth++; }
    int popOperandStack(int&) { int res = m_topBinaryExpr; m_topBinaryExpr = 0; return res; }
    

    void unaryTokenStackRemoveLast(int& stackDepth) { stackDepth = 0; }
    
    void assignmentStackAppend(int, int, int, int, int, Operator) { }
    int createAssignment(const JSTokenLocation&, int, int, int, int, int) { ASSERT_NOT_REACHED(); return 1; }
    const Identifier& getName(const Property& property) const { ASSERT(property.name); return *property.name; }
    PropertyNode::Type getType(const Property& property) const { return property.type; }
    bool isResolve(ExpressionType expr) const { return expr == ResolveExpr || expr == ResolveEvalExpr; }



    SourceIdToBreakpointsMap::iterator it = m_sourceIdToBreakpoints.find(sourceIDValue);
    if (it == m_sourceIdToBreakpoints.end())
        it = m_sourceIdToBreakpoints.set(sourceIDValue, LineToBreakpointMap()).iterator;
    LineToBreakpointMap::iterator breaksIt = it->second.find(scriptBreakpoint.lineNumber + 1);
    if (breaksIt == it->second.end())
        breaksIt = it->second.set(scriptBreakpoint.lineNumber + 1, BreakpointsInLine()).iterator;

    BreakpointsInLine& breaksVector = breaksIt->second;
    unsigned breaksCount = breaksVector.size();
    for (unsigned i = 0; i < breaksCount; i++) {
        if (breaksVector.at(i).columnNumber == scriptBreakpoint.columnNumber)
            return "";
    }
    breaksVector.append(scriptBreakpoint);

    *actualLineNumber = scriptBreakpoint.lineNumber;
    *actualColumnNumber = scriptBreakpoint.columnNumber;
    return sourceID + ":" + String::number(scriptBreakpoint.lineNumber) + ":" + String::number(scriptBreakpoint.columnNumber);
    return sourceID + ":" + String::number(scriptBreakpoint.lineNumber);
}

void ScriptDebugServer::removeBreakpoint(const String& breakpointId)
{
    Vector<String> tokens;
    breakpointId.split(":", tokens);
    if (tokens.size() != 3)
        return;
    bool success;
    intptr_t sourceIDValue = tokens[0].toIntPtr(&success);

    unsigned lineNumber = tokens[1].toUInt(&success);
    if (!success)
        return;
    unsigned columnNumber = tokens[2].toUInt(&success);
    if (!success)
        return;

    SourceIdToBreakpointsMap::iterator it = m_sourceIdToBreakpoints.find(sourceIDValue);
    if (it == m_sourceIdToBreakpoints.end())
        return;
    LineToBreakpointMap::iterator breaksIt = it->second.find(lineNumber + 1);
    if (breaksIt == it->second.end())
        return;

    BreakpointsInLine& breaksVector = breaksIt->second;
    unsigned breaksCount = breaksVector.size();
    for (unsigned i = 0; i < breaksCount; i++) {
        if (breaksVector.at(i).columnNumber == static_cast<int>(columnNumber)) {
            breaksVector.remove(i);
            break;
        }
    }
}

void ScriptDebugServer::updateCurrentStatementPosition(intptr_t sourceID, int line)
{
    if (line < 0)
        return;

    SourceProvider* source = reinterpret_cast<SourceProvider*>(sourceID);

    if (m_currentSourceID != sourceID) {
        String sourceCode = ustringToString(JSC::UString(const_cast<StringImpl*>(source->data())));
        m_currentSourceCode.clear();
        sourceCode.split("\n", true, m_currentSourceCode);
        m_currentSourceID = sourceID;
        m_currentStatementPosition.lineNumber = 0;
        m_currentStatementPosition.columnNumber = 0;
    }

    if (line != m_currentStatementPosition.lineNumber) {
        m_currentStatementPosition.lineNumber = line;
        m_currentStatementPosition.columnNumber = 0;
        return;
    }

    int startLine = source->startPosition().m_line.zeroBasedInt();
    if ((m_currentStatementPosition.lineNumber - startLine - 1) >= static_cast<int>(m_currentSourceCode.size()))
        return;
    const String& codeInLine = m_currentSourceCode[m_currentStatementPosition.lineNumber - startLine - 1];
    if (codeInLine.isEmpty())
        return;
    int nextColumn = codeInLine.find(";", m_currentStatementPosition.columnNumber);
    if (nextColumn != -1) {
        UChar c = codeInLine[nextColumn + 1];
        if (c == ' ' || c == '\t')
            nextColumn += 1;
        m_currentStatementPosition.columnNumber = nextColumn + 1;
    } else
        m_currentStatementPosition.columnNumber = 0;
}

bool ScriptDebugServer::hasBreakpoint(intptr_t sourceID, const TextPosition& position) const

    SourceIdToBreakpointsMap::const_iterator it = m_sourceIdToBreakpoints.find(sourceID);
    if (it == m_sourceIdToBreakpoints.end())
        return false;

    int lineNumber = position.m_line.zeroBasedInt();
    int columnNumber = position.m_column.zeroBasedInt();
    if (lineNumber < 0 || columnNumber < 0)
        return false;

    LineToBreakpointMap::const_iterator breaksIt = it->second.find(lineNumber + 1);
    if (breaksIt == it->second.end())
        return false;

    bool hit = false;
    const BreakpointsInLine& breaksVector = breaksIt->second;
    unsigned breaksCount = breaksVector.size();
    unsigned i;
    for (i = 0; i < breaksCount; i++) {
        int breakColumn = breaksVector.at(i).columnNumber;
        int breakLine = breaksVector.at(i).lineNumber;
        if (lineNumber == breakLine && columnNumber == breakColumn) {
            hit = true;
            break;
        }
    }
    if (!hit)
        return false;

    // An empty condition counts as no condition which is equivalent to "true".
    if (breaksVector.at(i).condition.isEmpty())
        return true;

    JSValue exception;
    JSValue result = m_currentCallFrame->evaluate(stringToUString(breaksVector.at(i).condition), exception);
    if (exception) {
        // An erroneous condition counts as "false".
        return false;

    m_callingListeners = false;
}

void ScriptDebugServer::createCallFrameAndPauseIfNeeded(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber)
{
    TextPosition textPosition(OrdinalNumber::fromOneBasedInt(lineNumber), OrdinalNumber::fromZeroBasedInt(columnNumber));
    m_currentCallFrame = JavaScriptCallFrame::create(debuggerCallFrame, m_currentCallFrame, sourceID, textPosition);
    pauseIfNeeded(debuggerCallFrame.dynamicGlobalObject());
}

void ScriptDebugServer::updateCallFrameAndPauseIfNeeded(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber)
{
    ASSERT(m_currentCallFrame);
    if (!m_currentCallFrame)
        return;

    TextPosition textPosition(OrdinalNumber::fromOneBasedInt(lineNumber), OrdinalNumber::fromZeroBasedInt(columnNumber));
    m_currentCallFrame->update(debuggerCallFrame, sourceID, textPosition);
    pauseIfNeeded(debuggerCallFrame.dynamicGlobalObject());
}


void ScriptDebugServer::callEvent(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)
{
    callEvent(debuggerCallFrame, sourceID, lineNumber, 0);
}

void ScriptDebugServer::callEvent(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber)
{
    if (!m_paused)
        createCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber, columnNumber);
}

void ScriptDebugServer::atStatement(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)
{
    atStatement(debuggerCallFrame, sourceID, lineNumber, 0);
}

void ScriptDebugServer::atStatement(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber)
{
    if (!m_paused)
        updateCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber, columnNumber);
}

void ScriptDebugServer::returnEvent(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)
{
    returnEvent(debuggerCallFrame, sourceID, lineNumber, 0);
}

void ScriptDebugServer::returnEvent(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber)
{
    if (m_paused)
        return;

    updateCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber, columnNumber);

    // detach may have been called during pauseIfNeeded
    if (!m_currentCallFrame)


void ScriptDebugServer::exception(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, bool hasHandler)
{
    exception(debuggerCallFrame, sourceID, lineNumber, 0, hasHandler);
}

void ScriptDebugServer::exception(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber, bool hasHandler)
{
    if (m_paused)
        return;

    if (m_pauseOnExceptionsState == PauseOnAllExceptions || (m_pauseOnExceptionsState == PauseOnUncaughtExceptions && !hasHandler))
        m_pauseOnNextStatement = true;

    updateCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber, columnNumber);
}

void ScriptDebugServer::willExecuteProgram(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)
{
    willExecuteProgram(debuggerCallFrame, sourceID, lineNumber, 0);
}

void ScriptDebugServer::willExecuteProgram(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber)
{
    if (!m_paused)
        createCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber, columnNumber);
}

void ScriptDebugServer::didExecuteProgram(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)
{
    didExecuteProgram(debuggerCallFrame, sourceID, lineNumber, 0);
}

void ScriptDebugServer::didExecuteProgram(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber)
{
    if (m_paused)
        return;

    updateCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber, columnNumber);

    // Treat stepping over the end of a program like stepping out.
    if (m_currentCallFrame == m_pauseOnCallFrame)


void ScriptDebugServer::didReachBreakpoint(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)
{
    didReachBreakpoint(debuggerCallFrame, sourceID, lineNumber, 0);
}

void ScriptDebugServer::didReachBreakpoint(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber)
{
    if (m_paused)
        return;

    m_pauseOnNextStatement = true;
    updateCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber, columnNumber);
}

void ScriptDebugServer::recompileAllJSFunctionsSoon()



    void dispatchDidParseSource(const ListenerSet& listeners, JSC::SourceProvider*, bool isContentScript);
    void dispatchFailedToParseSource(const ListenerSet& listeners, JSC::SourceProvider*, int errorLine, const String& errorMessage);

    void createCallFrameAndPauseIfNeeded(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineNumber, int columnNumber);
    void updateCallFrameAndPauseIfNeeded(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineNumber, int columnNumber);
    void pauseIfNeeded(JSC::JSGlobalObject* dynamicGlobalObject);

    virtual void detach(JSC::JSGlobalObject*);

    virtual void didExecuteProgram(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineno);
    virtual void didReachBreakpoint(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineno);

    virtual void callEvent(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineNumber, int columnNumber);
    virtual void atStatement(const JSC::DebuggerCallFrame&, intptr_t sourceID, int firstLine, int columnNumber);
    virtual void returnEvent(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineNumber, int columnNumber);
    virtual void exception(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineNumber, int columnNumber, bool hasHandler);
    virtual void willExecuteProgram(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineno, int columnNumber);
    virtual void didExecuteProgram(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineno, int columnNumber);
    virtual void didReachBreakpoint(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineno, int columnNumber);


    void updateCurrentStatementPosition(intptr_t, int);

    typedef Vector<ScriptBreakpoint> BreakpointsInLine;
    typedef HashMap<long, BreakpointsInLine> LineToBreakpointMap;
    typedef HashMap<intptr_t, LineToBreakpointMap> SourceIdToBreakpointsMap;

    bool m_callingListeners;

    RefPtr<JavaScriptCallFrame> m_currentCallFrame;
    SourceIdToBreakpointsMap m_sourceIdToBreakpoints;
    Timer<ScriptDebugServer> m_recompileTimer;

    Vector<String> m_currentSourceCode;
    intptr_t m_currentSourceID;
    ScriptBreakpoint m_currentStatementPosition;
};

} // namespace WebCore

Return to Bug 53003

Lines 2083-2089 void BytecodeGenerator::emitPopScope() a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp_sec1
- a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp -1 / +2 lines
2083	m_dynamicScopeDepth--;	2083	m_dynamicScopeDepth--;
2084	}	2084	}
2085		2085
2086	void BytecodeGenerator::emitDebugHook(DebugHookID debugHookID, int firstLine, int lastLine)	2086	void BytecodeGenerator::emitDebugHook(DebugHookID debugHookID, int firstLine, int lastLine, int column)
2087	{	2087	{
2088	#if ENABLE(DEBUG_WITH_BREAKPOINT)	2088	#if ENABLE(DEBUG_WITH_BREAKPOINT)
2089	if (debugHookID != DidReachBreakpoint)	2089	if (debugHookID != DidReachBreakpoint)
Lines 2096-2101 void BytecodeGenerator::emitDebugHook(DebugHookID debugHookID, int firstLine, in a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp_sec2
2096	instructions().append(debugHookID);	2096	instructions().append(debugHookID);
2097	instructions().append(firstLine);	2097	instructions().append(firstLine);
2098	instructions().append(lastLine);	2098	instructions().append(lastLine);
		2099	instructions().append(column);
2099	}	2100	}
2100		2101
2101	void BytecodeGenerator::pushFinallyContext(StatementNode* finallyBlock)	2102	void BytecodeGenerator::pushFinallyContext(StatementNode* finallyBlock)

Lines 3403-3410 DEFINE_STUB_FUNCTION(void, op_debug) a/Source/JavaScriptCore/jit/JITStubs.cpp_sec1
- a/Source/JavaScriptCore/jit/JITStubs.cpp -1 / +2 lines
3403	int debugHookID = stackFrame.args[0].int32();	3403	int debugHookID = stackFrame.args[0].int32();
3404	int firstLine = stackFrame.args[1].int32();	3404	int firstLine = stackFrame.args[1].int32();
3405	int lastLine = stackFrame.args[2].int32();	3405	int lastLine = stackFrame.args[2].int32();
		3406	int column = stackFrame.args[3].int32();
3406		3407
3407	stackFrame.globalData->interpreter->debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);	3408	stackFrame.globalData->interpreter->debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine, column);
3408	}	3409	}
3409		3410
3410	DEFINE_STUB_FUNCTION(void*, vm_throw)	3411	DEFINE_STUB_FUNCTION(void*, vm_throw)

Lines 1601-1608 LLINT_SLOW_PATH_DECL(slow_path_debug) a/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp_sec1
- a/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp -2 / +3 lines
1601	int debugHookID = pc[1].u.operand;	1601	int debugHookID = pc[1].u.operand;
1602	int firstLine = pc[2].u.operand;	1602	int firstLine = pc[2].u.operand;
1603	int lastLine = pc[3].u.operand;	1603	int lastLine = pc[3].u.operand;
1604		1604	int column = pc[4].u.operand;
1605	globalData.interpreter->debug(exec, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);	1605
		1606	globalData.interpreter->debug(exec, static_cast<DebugHookID>(debugHookID), firstLine, lastLine, column);
1606		1607
1607	LLINT_END();	1608	LLINT_END();
1608	}	1609	}

Lines 1-3 a/Source/JavaScriptCore/ChangeLog_sec1
- a/Source/JavaScriptCore/ChangeLog +466 lines
		1	2012-08-01 Peter Wang <peter.wang@torchmobile.com.cn>
		2
		3	Web Inspector: [JSC] implement setting breakpoints by line:column
		4	https://bugs.webkit.org/show_bug.cgi?id=53003
		5
		6	Reviewed by Geoffrey Garen.
		7
		8	Add a counter in lexer to record the column of each token. Debugger will use column info
		9	in "Pretty Print" debug mode of Inspector.
		10
		11	* bytecode/Opcode.h:
		12	(JSC):
		13	(JSC::padOpcodeName):
		14	* bytecompiler/BytecodeGenerator.cpp:
		15	(JSC::BytecodeGenerator::emitDebugHook):
		16	* bytecompiler/BytecodeGenerator.h:
		17	(BytecodeGenerator):
		18	* bytecompiler/NodesCodegen.cpp:
		19	(JSC::ArrayNode::toArgumentList):
		20	(JSC::ApplyFunctionCallDotNode::emitBytecode):
		21	(JSC::ConditionalNode::emitBytecode):
		22	(JSC::ConstStatementNode::emitBytecode):
		23	(JSC::EmptyStatementNode::emitBytecode):
		24	(JSC::DebuggerStatementNode::emitBytecode):
		25	(JSC::ExprStatementNode::emitBytecode):
		26	(JSC::VarStatementNode::emitBytecode):
		27	(JSC::IfNode::emitBytecode):
		28	(JSC::IfElseNode::emitBytecode):
		29	(JSC::DoWhileNode::emitBytecode):
		30	(JSC::WhileNode::emitBytecode):
		31	(JSC::ForNode::emitBytecode):
		32	(JSC::ForInNode::emitBytecode):
		33	(JSC::ContinueNode::emitBytecode):
		34	(JSC::BreakNode::emitBytecode):
		35	(JSC::ReturnNode::emitBytecode):
		36	(JSC::WithNode::emitBytecode):
		37	(JSC::SwitchNode::emitBytecode):
		38	(JSC::LabelNode::emitBytecode):
		39	(JSC::ThrowNode::emitBytecode):
		40	(JSC::TryNode::emitBytecode):
		41	(JSC::ProgramNode::emitBytecode):
		42	(JSC::EvalNode::emitBytecode):
		43	(JSC::FunctionBodyNode::emitBytecode):
		44	* debugger/Debugger.h:
		45	* interpreter/Interpreter.cpp:
		46	(JSC::Interpreter::unwindCallFrame):
		47	(JSC::Interpreter::throwException):
		48	(JSC::Interpreter::debug):
		49	* interpreter/Interpreter.h:
		50	(Interpreter):
		51	* jit/JITOpcodes.cpp:
		52	(JSC::JIT::emit_op_debug):
		53	* jit/JITOpcodes32_64.cpp:
		54	(JSC::JIT::emit_op_debug):
		55	* jit/JITStubs.cpp:
		56	(JSC::DEFINE_STUB_FUNCTION):
		57	* llint/LLIntSlowPaths.cpp:
		58	(JSC::LLInt::LLINT_SLOW_PATH_DECL):
		59	* parser/ASTBuilder.h:
		60	(ASTBuilder):
		61	(JSC::ASTBuilder::createCommaExpr):
		62	(JSC::ASTBuilder::createLogicalNot):
		63	(JSC::ASTBuilder::createUnaryPlus):
		64	(JSC::ASTBuilder::createVoid):
65	(JSC::ASTBuilder::thisExpr):
66	(JSC::ASTBuilder::createResolve):
67	(JSC::ASTBuilder::createObjectLiteral):
68	(JSC::ASTBuilder::createArray):
69	(JSC::ASTBuilder::createNumberExpr):
70	(JSC::ASTBuilder::createString):
71	(JSC::ASTBuilder::createBoolean):
72	(JSC::ASTBuilder::createNull):
73	(JSC::ASTBuilder::createBracketAccess):
74	(JSC::ASTBuilder::createDotAccess):
75	(JSC::ASTBuilder::createRegExp):
76	(JSC::ASTBuilder::createNewExpr):
77	(JSC::ASTBuilder::createConditionalExpr):
78	(JSC::ASTBuilder::createAssignResolve):
79	(JSC::ASTBuilder::createFunctionExpr):
80	(JSC::ASTBuilder::createFunctionBody):
81	(JSC::ASTBuilder::createGetterOrSetterProperty):
82	(JSC::ASTBuilder::createArgumentsList):
83	(JSC::ASTBuilder::createPropertyList):
84	(JSC::ASTBuilder::createFuncDeclStatement):
85	(JSC::ASTBuilder::createBlockStatement):
86	(JSC::ASTBuilder::createExprStatement):
87	(JSC::ASTBuilder::createIfStatement):
88	(JSC::ASTBuilder::createForLoop):
89	(JSC::ASTBuilder::createForInLoop):
90	(JSC::ASTBuilder::createEmptyStatement):
91	(JSC::ASTBuilder::createVarStatement):
92	(JSC::ASTBuilder::createReturnStatement):
93	(JSC::ASTBuilder::createBreakStatement):
94	(JSC::ASTBuilder::createContinueStatement):
95	(JSC::ASTBuilder::createTryStatement):
96	(JSC::ASTBuilder::createSwitchStatement):
97	(JSC::ASTBuilder::createWhileStatement):
98	(JSC::ASTBuilder::createDoWhileStatement):
99	(JSC::ASTBuilder::createLabelStatement):
100	(JSC::ASTBuilder::createWithStatement):
101	(JSC::ASTBuilder::createThrowStatement):
102	(JSC::ASTBuilder::createDebugger):
103	(JSC::ASTBuilder::createConstStatement):
104	(JSC::ASTBuilder::appendConstDecl):
105	(JSC::ASTBuilder::combineCommaNodes):
106	(JSC::ASTBuilder::appendBinaryOperation):
107	(JSC::ASTBuilder::createAssignment):
108	(JSC::ASTBuilder::createNumber):
109	(JSC::ASTBuilder::makeTypeOfNode):
110	(JSC::ASTBuilder::makeDeleteNode):
111	(JSC::ASTBuilder::makeNegateNode):
112	(JSC::ASTBuilder::makeBitwiseNotNode):
113	(JSC::ASTBuilder::makeMultNode):
114	(JSC::ASTBuilder::makeDivNode):
115	(JSC::ASTBuilder::makeModNode):
116	(JSC::ASTBuilder::makeAddNode):
117	(JSC::ASTBuilder::makeSubNode):
118	(JSC::ASTBuilder::makeLeftShiftNode):
119	(JSC::ASTBuilder::makeRightShiftNode):
120	(JSC::ASTBuilder::makeURightShiftNode):
121	(JSC::ASTBuilder::makeBitOrNode):
122	(JSC::ASTBuilder::makeBitAndNode):
123	(JSC::ASTBuilder::makeBitXOrNode):
124	(JSC::ASTBuilder::makeFunctionCallNode):
125	(JSC::ASTBuilder::makeBinaryNode):
126	(JSC::ASTBuilder::makeAssignNode):
127	(JSC::ASTBuilder::makePrefixNode):
128	(JSC::ASTBuilder::makePostfixNode):
129	* parser/Lexer.cpp:
130	(JSC::::setCode):
131	(JSC::::internalShift):
132	(JSC::::shift):
133	(JSC::::lex):
134	* parser/Lexer.h:
135	(Lexer):
136	(JSC::Lexer::currentColumnNumber):
137	(JSC::::lexExpectIdentifier):
138	* parser/NodeConstructors.h:
139	(JSC::Node::Node):
140	(JSC::ExpressionNode::ExpressionNode):
141	(JSC::StatementNode::StatementNode):
142	(JSC::NullNode::NullNode):
143	(JSC::BooleanNode::BooleanNode):
144	(JSC::NumberNode::NumberNode):
145	(JSC::StringNode::StringNode):
146	(JSC::RegExpNode::RegExpNode):
147	(JSC::ThisNode::ThisNode):
148	(JSC::ResolveNode::ResolveNode):
149	(JSC::ArrayNode::ArrayNode):
150	(JSC::PropertyListNode::PropertyListNode):
151	(JSC::ObjectLiteralNode::ObjectLiteralNode):
152	(JSC::BracketAccessorNode::BracketAccessorNode):
153	(JSC::DotAccessorNode::DotAccessorNode):
154	(JSC::ArgumentListNode::ArgumentListNode):
155	(JSC::NewExprNode::NewExprNode):
156	(JSC::EvalFunctionCallNode::EvalFunctionCallNode):
157	(JSC::FunctionCallValueNode::FunctionCallValueNode):
158	(JSC::FunctionCallResolveNode::FunctionCallResolveNode):
159	(JSC::FunctionCallBracketNode::FunctionCallBracketNode):
160	(JSC::FunctionCallDotNode::FunctionCallDotNode):
161	(JSC::CallFunctionCallDotNode::CallFunctionCallDotNode):
162	(JSC::ApplyFunctionCallDotNode::ApplyFunctionCallDotNode):
163	(JSC::PrePostResolveNode::PrePostResolveNode):
164	(JSC::PostfixResolveNode::PostfixResolveNode):
165	(JSC::PostfixBracketNode::PostfixBracketNode):
166	(JSC::PostfixDotNode::PostfixDotNode):
167	(JSC::PostfixErrorNode::PostfixErrorNode):
168	(JSC::DeleteResolveNode::DeleteResolveNode):
169	(JSC::DeleteBracketNode::DeleteBracketNode):
170	(JSC::DeleteDotNode::DeleteDotNode):
171	(JSC::DeleteValueNode::DeleteValueNode):
172	(JSC::VoidNode::VoidNode):
173	(JSC::TypeOfResolveNode::TypeOfResolveNode):
174	(JSC::TypeOfValueNode::TypeOfValueNode):
175	(JSC::PrefixResolveNode::PrefixResolveNode):
176	(JSC::PrefixBracketNode::PrefixBracketNode):
177	(JSC::PrefixDotNode::PrefixDotNode):
178	(JSC::PrefixErrorNode::PrefixErrorNode):
179	(JSC::UnaryOpNode::UnaryOpNode):
180	(JSC::UnaryPlusNode::UnaryPlusNode):
181	(JSC::NegateNode::NegateNode):
182	(JSC::BitwiseNotNode::BitwiseNotNode):
183	(JSC::LogicalNotNode::LogicalNotNode):
184	(JSC::BinaryOpNode::BinaryOpNode):
185	(JSC::MultNode::MultNode):
186	(JSC::DivNode::DivNode):
187	(JSC::ModNode::ModNode):
188	(JSC::AddNode::AddNode):
189	(JSC::SubNode::SubNode):
190	(JSC::LeftShiftNode::LeftShiftNode):
191	(JSC::RightShiftNode::RightShiftNode):
192	(JSC::UnsignedRightShiftNode::UnsignedRightShiftNode):
193	(JSC::LessNode::LessNode):
194	(JSC::GreaterNode::GreaterNode):
195	(JSC::LessEqNode::LessEqNode):
196	(JSC::GreaterEqNode::GreaterEqNode):
197	(JSC::ThrowableBinaryOpNode::ThrowableBinaryOpNode):
198	(JSC::InstanceOfNode::InstanceOfNode):
199	(JSC::InNode::InNode):
200	(JSC::EqualNode::EqualNode):
201	(JSC::NotEqualNode::NotEqualNode):
202	(JSC::StrictEqualNode::StrictEqualNode):
203	(JSC::NotStrictEqualNode::NotStrictEqualNode):
204	(JSC::BitAndNode::BitAndNode):
205	(JSC::BitOrNode::BitOrNode):
206	(JSC::BitXOrNode::BitXOrNode):
207	(JSC::LogicalOpNode::LogicalOpNode):
208	(JSC::ConditionalNode::ConditionalNode):
209	(JSC::ReadModifyResolveNode::ReadModifyResolveNode):
210	(JSC::AssignResolveNode::AssignResolveNode):
211	(JSC::ReadModifyBracketNode::ReadModifyBracketNode):
212	(JSC::AssignBracketNode::AssignBracketNode):
213	(JSC::AssignDotNode::AssignDotNode):
214	(JSC::ReadModifyDotNode::ReadModifyDotNode):
215	(JSC::AssignErrorNode::AssignErrorNode):
216	(JSC::CommaNode::CommaNode):
217	(JSC::ConstStatementNode::ConstStatementNode):
218	(JSC::EmptyStatementNode::EmptyStatementNode):
219	(JSC::DebuggerStatementNode::DebuggerStatementNode):
220	(JSC::ExprStatementNode::ExprStatementNode):
221	(JSC::VarStatementNode::VarStatementNode):
222	(JSC::IfNode::IfNode):
223	(JSC::IfElseNode::IfElseNode):
224	(JSC::DoWhileNode::DoWhileNode):
225	(JSC::WhileNode::WhileNode):
226	(JSC::ForNode::ForNode):
227	(JSC::ContinueNode::ContinueNode):
228	(JSC::BreakNode::BreakNode):
229	(JSC::ReturnNode::ReturnNode):
230	(JSC::WithNode::WithNode):
231	(JSC::LabelNode::LabelNode):
232	(JSC::ThrowNode::ThrowNode):
233	(JSC::TryNode::TryNode):
234	(JSC::FuncExprNode::FuncExprNode):
235	(JSC::FuncDeclNode::FuncDeclNode):
236	(JSC::SwitchNode::SwitchNode):
237	(JSC::ConstDeclNode::ConstDeclNode):
238	(JSC::BlockNode::BlockNode):
239	(JSC::ForInNode::ForInNode):
240	* parser/Nodes.cpp:
241	(JSC::StatementNode::setLoc):
242	(JSC):
243	(JSC::ScopeNode::ScopeNode):
244	(JSC::ProgramNode::ProgramNode):
245	(JSC::ProgramNode::create):
246	(JSC::EvalNode::EvalNode):
247	(JSC::EvalNode::create):
248	(JSC::FunctionBodyNode::FunctionBodyNode):
249	(JSC::FunctionBodyNode::create):
250	* parser/Nodes.h:
251	(Node):
252	(JSC::Node::columnNo):
253	(ExpressionNode):
254	(StatementNode):
255	(JSC::StatementNode::column):
256	(NullNode):
257	(BooleanNode):
258	(NumberNode):
259	(StringNode):
260	(RegExpNode):
261	(ThisNode):
262	(ResolveNode):
263	(ArrayNode):
264	(PropertyListNode):
265	(ObjectLiteralNode):
266	(BracketAccessorNode):
267	(DotAccessorNode):
268	(ArgumentListNode):
269	(NewExprNode):
270	(EvalFunctionCallNode):
271	(FunctionCallValueNode):
272	(FunctionCallResolveNode):
273	(FunctionCallBracketNode):
274	(FunctionCallDotNode):
275	(CallFunctionCallDotNode):
276	(ApplyFunctionCallDotNode):
277	(PrePostResolveNode):
278	(PostfixResolveNode):
279	(PostfixBracketNode):
280	(PostfixDotNode):
281	(PostfixErrorNode):
282	(DeleteResolveNode):
283	(DeleteBracketNode):
284	(DeleteDotNode):
285	(DeleteValueNode):
286	(VoidNode):
287	(TypeOfResolveNode):
288	(TypeOfValueNode):
289	(PrefixResolveNode):
290	(PrefixBracketNode):
291	(PrefixDotNode):
292	(PrefixErrorNode):
293	(UnaryOpNode):
294	(UnaryPlusNode):
295	(NegateNode):
296	(BitwiseNotNode):
297	(LogicalNotNode):
298	(BinaryOpNode):
299	(MultNode):
300	(DivNode):
301	(ModNode):
302	(AddNode):
303	(SubNode):
304	(LeftShiftNode):
305	(RightShiftNode):
306	(UnsignedRightShiftNode):
307	(LessNode):
308	(GreaterNode):
309	(LessEqNode):
310	(GreaterEqNode):
311	(ThrowableBinaryOpNode):
312	(InstanceOfNode):
313	(InNode):
314	(EqualNode):
315	(NotEqualNode):
316	(StrictEqualNode):
317	(NotStrictEqualNode):
318	(BitAndNode):
319	(BitOrNode):
320	(BitXOrNode):
321	(LogicalOpNode):
322	(ConditionalNode):
323	(ReadModifyResolveNode):
324	(AssignResolveNode):
325	(ReadModifyBracketNode):
326	(AssignBracketNode):
327	(AssignDotNode):
328	(ReadModifyDotNode):
329	(AssignErrorNode):
330	(CommaNode):
331	(ConstDeclNode):
332	(ConstStatementNode):
333	(BlockNode):
334	(EmptyStatementNode):
335	(DebuggerStatementNode):
336	(ExprStatementNode):
337	(VarStatementNode):
338	(IfNode):
339	(IfElseNode):
340	(DoWhileNode):
341	(WhileNode):
342	(ForNode):
343	(ForInNode):
344	(ContinueNode):
345	(BreakNode):
346	(ReturnNode):
347	(WithNode):
348	(LabelNode):
349	(ThrowNode):
350	(TryNode):
351	(ScopeNode):
352	(ProgramNode):
353	(EvalNode):
354	(FunctionBodyNode):
355	(FuncExprNode):
356	(FuncDeclNode):
357	(SwitchNode):
358	* parser/Parser.cpp:
359	(JSC::::parseSourceElements):
360	(JSC::::parseVarDeclaration):
361	(JSC::::parseConstDeclaration):
362	(JSC::::parseDoWhileStatement):
363	(JSC::::parseWhileStatement):
364	(JSC::::parseVarDeclarationList):
365	(JSC::::parseConstDeclarationList):
366	(JSC::::parseForStatement):
367	(JSC::::parseBreakStatement):
368	(JSC::::parseContinueStatement):
369	(JSC::::parseReturnStatement):
370	(JSC::::parseThrowStatement):
371	(JSC::::parseWithStatement):
372	(JSC::::parseSwitchStatement):
373	(JSC::::parseTryStatement):
374	(JSC::::parseDebuggerStatement):
375	(JSC::::parseBlockStatement):
376	(JSC::::parseStatement):
377	(JSC::::parseFunctionBody):
378	(JSC::::parseFunctionInfo):
379	(JSC::::parseFunctionDeclaration):
380	(JSC::::parseExpressionOrLabelStatement):
381	(JSC::::parseExpressionStatement):
382	(JSC::::parseIfStatement):
383	(JSC::::parseExpression):
384	(JSC::::parseAssignmentExpression):
385	(JSC::::parseConditionalExpression):
386	(JSC::::parseBinaryExpression):
387	(JSC::::parseProperty):
388	(JSC::::parseObjectLiteral):
389	(JSC::::parseStrictObjectLiteral):
390	(JSC::::parseArrayLiteral):
391	(JSC::::parsePrimaryExpression):
392	(JSC::::parseArguments):
393	(JSC::::parseMemberExpression):
394	(JSC::::parseUnaryExpression):
395	* parser/Parser.h:
396	(JSC::Parser::next):
397	(JSC::Parser::nextExpectIdentifier):
398	(JSC::Parser::tokenStart):
399	(JSC::Parser::tokenLine):
400	(JSC::Parser::tokenEnd):
401	(JSC::Parser::tokenLocation):
402	(Parser):
403	(JSC::Parser::getTokenName):
404	(JSC::::parse):
405	* parser/ParserTokens.h:
406	(JSC::JSTokenLocation::JSTokenLocation):
407	(JSTokenLocation):
408	(JSToken):
409	* parser/SourceProviderCacheItem.h:
410	(JSC::SourceProviderCacheItem::closeBraceToken):
411	* parser/SyntaxChecker.h:
412	(JSC::SyntaxChecker::makeFunctionCallNode):
413	(JSC::SyntaxChecker::createCommaExpr):
414	(JSC::SyntaxChecker::makeAssignNode):
415	(JSC::SyntaxChecker::makePrefixNode):
416	(JSC::SyntaxChecker::makePostfixNode):
417	(JSC::SyntaxChecker::makeTypeOfNode):
418	(JSC::SyntaxChecker::makeDeleteNode):
419	(JSC::SyntaxChecker::makeNegateNode):
420	(JSC::SyntaxChecker::makeBitwiseNotNode):
421	(JSC::SyntaxChecker::createLogicalNot):
422	(JSC::SyntaxChecker::createUnaryPlus):
423	(JSC::SyntaxChecker::createVoid):
424	(JSC::SyntaxChecker::thisExpr):
425	(JSC::SyntaxChecker::createResolve):
426	(JSC::SyntaxChecker::createObjectLiteral):
427	(JSC::SyntaxChecker::createArray):
428	(JSC::SyntaxChecker::createNumberExpr):
429	(JSC::SyntaxChecker::createString):
430	(JSC::SyntaxChecker::createBoolean):
431	(JSC::SyntaxChecker::createNull):
432	(JSC::SyntaxChecker::createBracketAccess):
433	(JSC::SyntaxChecker::createDotAccess):
434	(JSC::SyntaxChecker::createRegExp):
435	(JSC::SyntaxChecker::createNewExpr):
436	(JSC::SyntaxChecker::createConditionalExpr):
437	(JSC::SyntaxChecker::createAssignResolve):
438	(JSC::SyntaxChecker::createFunctionExpr):
439	(JSC::SyntaxChecker::createFunctionBody):
440	(JSC::SyntaxChecker::createArgumentsList):
441	(JSC::SyntaxChecker::createPropertyList):
442	(JSC::SyntaxChecker::createFuncDeclStatement):
443	(JSC::SyntaxChecker::createBlockStatement):
444	(JSC::SyntaxChecker::createExprStatement):
445	(JSC::SyntaxChecker::createIfStatement):
446	(JSC::SyntaxChecker::createForLoop):
447	(JSC::SyntaxChecker::createForInLoop):
448	(JSC::SyntaxChecker::createEmptyStatement):
449	(JSC::SyntaxChecker::createVarStatement):
450	(JSC::SyntaxChecker::createReturnStatement):
451	(JSC::SyntaxChecker::createBreakStatement):
452	(JSC::SyntaxChecker::createContinueStatement):
453	(JSC::SyntaxChecker::createTryStatement):
454	(JSC::SyntaxChecker::createSwitchStatement):
455	(JSC::SyntaxChecker::createWhileStatement):
456	(JSC::SyntaxChecker::createWithStatement):
457	(JSC::SyntaxChecker::createDoWhileStatement):
458	(JSC::SyntaxChecker::createLabelStatement):
459	(JSC::SyntaxChecker::createThrowStatement):
460	(JSC::SyntaxChecker::createDebugger):
461	(JSC::SyntaxChecker::createConstStatement):
462	(JSC::SyntaxChecker::appendConstDecl):
463	(JSC::SyntaxChecker::createGetterOrSetterProperty):
464	(JSC::SyntaxChecker::combineCommaNodes):
465	(JSC::SyntaxChecker::operatorStackPop):
466
1	2012-08-01 Filip Pizlo <fpizlo@apple.com>	467	2012-08-01 Filip Pizlo <fpizlo@apple.com>
2		468
3	DFG should distinguish between PutByVal's that clobber the world and ones that don't	469	DFG should distinguish between PutByVal's that clobber the world and ones that don't

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +30 lines
		1	2012-08-01 Peter Wang <peter.wang@torchmobile.com.cn>
		2
		3	Web Inspector: [JSC] implement setting breakpoints by line:column
		4	https://bugs.webkit.org/show_bug.cgi?id=53003
		5
		6	Reviewed by Geoffrey Garen.
		7
		8	As JSC is enabled to provide column info of statement, ScriptDebugServer can use it to
		9	support "Pretty Print" debug mode.
		10
		11	No new test case for this patch.
		12
		13	* bindings/js/ScriptDebugServer.cpp:
		14	(WebCore::ScriptDebugServer::setBreakpoint):
		15	(WebCore::ScriptDebugServer::removeBreakpoint):
		16	(WebCore):
		17	(WebCore::ScriptDebugServer::updateCurrentStatementPosition):
		18	(WebCore::ScriptDebugServer::hasBreakpoint):
		19	(WebCore::ScriptDebugServer::createCallFrameAndPauseIfNeeded):
		20	(WebCore::ScriptDebugServer::updateCallFrameAndPauseIfNeeded):
		21	(WebCore::ScriptDebugServer::callEvent):
		22	(WebCore::ScriptDebugServer::atStatement):
		23	(WebCore::ScriptDebugServer::returnEvent):
		24	(WebCore::ScriptDebugServer::exception):
		25	(WebCore::ScriptDebugServer::willExecuteProgram):
		26	(WebCore::ScriptDebugServer::didExecuteProgram):
		27	(WebCore::ScriptDebugServer::didReachBreakpoint):
		28	* bindings/js/ScriptDebugServer.h:
		29	(ScriptDebugServer):
		30
1	2012-08-01 Xingnan Wang <xingnan.wang@intel.com>	31	2012-08-01 Xingnan Wang <xingnan.wang@intel.com>
2		32
3	IndexedDB: ObjectStoreMetaDataKey::m_metaDataType should use byte type	33	IndexedDB: ObjectStoreMetaDataKey::m_metaDataType should use byte type

Lines 42-55 namespace JSC { a/Source/JavaScriptCore/debugger/Debugger.h_sec1
- a/Source/JavaScriptCore/debugger/Debugger.h -8 / +19 lines
42	virtual void detach(JSGlobalObject*);	42	virtual void detach(JSGlobalObject*);
43		43
44	virtual void sourceParsed(ExecState, SourceProvider, int errorLineNumber, const UString& errorMessage) = 0;	44	virtual void sourceParsed(ExecState, SourceProvider, int errorLineNumber, const UString& errorMessage) = 0;
45	virtual void exception(const DebuggerCallFrame&, intptr_t sourceID, int lineNumber, bool hasHandler) = 0;	45	virtual void exception(const DebuggerCallFrame&, intptr_t, int, bool) = 0;
46	virtual void atStatement(const DebuggerCallFrame&, intptr_t sourceID, int lineNumber) = 0;	46	virtual void atStatement(const DebuggerCallFrame&, intptr_t, int) = 0;
47	virtual void callEvent(const DebuggerCallFrame&, intptr_t sourceID, int lineNumber) = 0;	47	virtual void callEvent(const DebuggerCallFrame&, intptr_t, int) = 0;
48	virtual void returnEvent(const DebuggerCallFrame&, intptr_t sourceID, int lineNumber) = 0;	48	virtual void returnEvent(const DebuggerCallFrame&, intptr_t, int) = 0;
49		49
50	virtual void willExecuteProgram(const DebuggerCallFrame&, intptr_t sourceID, int lineNumber) = 0;	50	virtual void exception(const DebuggerCallFrame&, intptr_t, int, int, bool) { };
51	virtual void didExecuteProgram(const DebuggerCallFrame&, intptr_t sourceID, int lineNumber) = 0;	51	virtual void atStatement(const DebuggerCallFrame&, intptr_t, int, int) { };
52	virtual void didReachBreakpoint(const DebuggerCallFrame&, intptr_t sourceID, int lineNumber) = 0;	52	virtual void callEvent(const DebuggerCallFrame&, intptr_t, int, int) { };
		53	virtual void returnEvent(const DebuggerCallFrame&, intptr_t, int, int) { };
		54
		55
		56	virtual void willExecuteProgram(const DebuggerCallFrame&, intptr_t, int) = 0;
		57	virtual void didExecuteProgram(const DebuggerCallFrame&, intptr_t, int) = 0;
		58	virtual void didReachBreakpoint(const DebuggerCallFrame&, intptr_t, int) = 0;
		59
		60	virtual void willExecuteProgram(const DebuggerCallFrame&, intptr_t, int, int) { };
		61	virtual void didExecuteProgram(const DebuggerCallFrame&, intptr_t, int, int) { };
		62	virtual void didReachBreakpoint(const DebuggerCallFrame&, intptr_t, int, int) { };
		63
53		64
54	void recompileAllJSFunctions(JSGlobalData*);	65	void recompileAllJSFunctions(JSGlobalData*);
55		66

Lines 730-738 NEVER_INLINE bool Interpreter::unwindCallFrame(CallFrame*& callFrame, JSValue ex a/Source/JavaScriptCore/interpreter/Interpreter.cpp_sec1
- a/Source/JavaScriptCore/interpreter/Interpreter.cpp -10 / +10 lines
730	if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {	730	if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {
731	DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);	731	DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);
732	if (callFrame->callee())	732	if (callFrame->callee())
733	debugger->returnEvent(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->lastLine());	733	debugger->returnEvent(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->lastLine(), 0);
734	else	734	else
735	debugger->didExecuteProgram(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->lastLine());	735	debugger->didExecuteProgram(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->lastLine(), 0);
736	}	736	}
737		737
738	// If this call frame created an activation or an 'arguments' object, tear it off.	738	// If this call frame created an activation or an 'arguments' object, tear it off.
Lines 1055-1061 NEVER_INLINE HandlerInfo* Interpreter::throwException(CallFrame*& callFrame, JSV a/Source/JavaScriptCore/interpreter/Interpreter.cpp_sec2
1055	if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {	1055	if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {
1056	DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);	1056	DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);
1057	bool hasHandler = codeBlock->handlerForBytecodeOffset(bytecodeOffset);	1057	bool hasHandler = codeBlock->handlerForBytecodeOffset(bytecodeOffset);
1058	debugger->exception(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->lineNumberForBytecodeOffset(bytecodeOffset), hasHandler);	1058	debugger->exception(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->lineNumberForBytecodeOffset(bytecodeOffset), 0, hasHandler);
1059	}	1059	}
1060		1060
1061	// Calculate an exception handler vPC, unwinding call frames as necessary.	1061	// Calculate an exception handler vPC, unwinding call frames as necessary.
Lines 1643-1649 JSValue Interpreter::execute(EvalExecutable* eval, CallFrame* callFrame, JSValue a/Source/JavaScriptCore/interpreter/Interpreter.cpp_sec3
1643	return checkedReturn(result);	1643	return checkedReturn(result);
1644	}	1644	}
1645		1645
1646	NEVER_INLINE void Interpreter::debug(CallFrame* callFrame, DebugHookID debugHookID, int firstLine, int lastLine)	1646	NEVER_INLINE void Interpreter::debug(CallFrame* callFrame, DebugHookID debugHookID, int firstLine, int lastLine, int column)
1647	{	1647	{
1648	Debugger* debugger = callFrame->dynamicGlobalObject()->debugger();	1648	Debugger* debugger = callFrame->dynamicGlobalObject()->debugger();
1649	if (!debugger)	1649	if (!debugger)
Lines 1651-1672 NEVER_INLINE void Interpreter::debug(CallFrame* callFrame, DebugHookID debugHook a/Source/JavaScriptCore/interpreter/Interpreter.cpp_sec4
1651		1651
1652	switch (debugHookID) {	1652	switch (debugHookID) {
1653	case DidEnterCallFrame:	1653	case DidEnterCallFrame:
1654	debugger->callEvent(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine);	1654	debugger->callEvent(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine, column);
1655	return;	1655	return;
1656	case WillLeaveCallFrame:	1656	case WillLeaveCallFrame:
1657	debugger->returnEvent(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine);	1657	debugger->returnEvent(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine, column);
1658	return;	1658	return;
1659	case WillExecuteStatement:	1659	case WillExecuteStatement:
1660	debugger->atStatement(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine);	1660	debugger->atStatement(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine, column);
1661	return;	1661	return;
1662	case WillExecuteProgram:	1662	case WillExecuteProgram:
1663	debugger->willExecuteProgram(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine);	1663	debugger->willExecuteProgram(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine, column);
1664	return;	1664	return;
1665	case DidExecuteProgram:	1665	case DidExecuteProgram:
1666	debugger->didExecuteProgram(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine);	1666	debugger->didExecuteProgram(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine, column);
1667	return;	1667	return;
1668	case DidReachBreakpoint:	1668	case DidReachBreakpoint:
1669	debugger->didReachBreakpoint(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine);	1669	debugger->didReachBreakpoint(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine, column);
1670	return;	1670	return;
1671	}	1671	}
1672	}	1672	}

Lines 417-422 void Lexer<T>::setCode(const SourceCode& source, ParserArena* arena) a/Source/JavaScriptCore/parser/Lexer.cpp_sec1
- a/Source/JavaScriptCore/parser/Lexer.cpp -6 / +12 lines
417	m_codeEnd = m_codeStart + source.endOffset();	417	m_codeEnd = m_codeStart + source.endOffset();
418	m_error = false;	418	m_error = false;
419	m_atLineStart = true;	419	m_atLineStart = true;
		420	m_columnNumber = 0;
420	m_lexErrorMessage = UString();	421	m_lexErrorMessage = UString();
421		422
422	m_buffer8.reserveInitialCapacity(initialReadBufferCapacity);	423	m_buffer8.reserveInitialCapacity(initialReadBufferCapacity);
Lines 433-438 template <typename T> a/Source/JavaScriptCore/parser/Lexer.cpp_sec2
433	template <int shiftAmount> ALWAYS_INLINE void Lexer<T>::internalShift()	434	template <int shiftAmount> ALWAYS_INLINE void Lexer<T>::internalShift()
434	{	435	{
435	m_code += shiftAmount;	436	m_code += shiftAmount;
		437	m_columnNumber += shiftAmount;
436	m_current = *m_code;	438	m_current = *m_code;
437	}	439	}
438		440
Lines 444-449 ALWAYS_INLINE void Lexer<T>::shift() a/Source/JavaScriptCore/parser/Lexer.cpp_sec3
444	++m_code;	446	++m_code;
445	if (LIKELY(m_code < m_codeEnd))	447	if (LIKELY(m_code < m_codeEnd))
446	m_current = *m_code;	448	m_current = *m_code;
		449	++m_columnNumber;
447	}	450	}
448		451
449	template <typename T>	452	template <typename T>
Lines 1183-1189 bool Lexer<T>::nextTokenIsColon() a/Source/JavaScriptCore/parser/Lexer.cpp_sec4
1183	}	1186	}
1184		1187
1185	template <typename T>	1188	template <typename T>
1186	JSTokenType Lexer<T>::lex(JSTokenData* tokenData, JSTokenInfo* tokenInfo, unsigned lexerFlags, bool strictMode)	1189	JSTokenType Lexer<T>::lex(JSTokenData* tokenData, JSTokenLocation* tokenLocation, unsigned lexerFlags, bool strictMode)
1187	{	1190	{
1188	ASSERT(!m_error);	1191	ASSERT(!m_error);
1189	ASSERT(m_buffer8.isEmpty());	1192	ASSERT(m_buffer8.isEmpty());
Lines 1199-1205 start: a/Source/JavaScriptCore/parser/Lexer.cpp_sec5
1199	if (atEnd())	1202	if (atEnd())
1200	return EOFTOK;	1203	return EOFTOK;
1201		1204
1202	tokenInfo->startOffset = currentOffset();	1205	tokenLocation->startOffset = currentOffset();
		1206	tokenLocation->column = m_columnNumber;
1203		1207
1204	CharacterType type;	1208	CharacterType type;
1205	if (LIKELY(isLatin1(m_current)))	1209	if (LIKELY(isLatin1(m_current)))
Lines 1522-1527 inNumberAfterDecimalPoint: a/Source/JavaScriptCore/parser/Lexer.cpp_sec6
1522	shiftLineTerminator();	1526	shiftLineTerminator();
1523	m_atLineStart = true;	1527	m_atLineStart = true;
1524	m_terminator = true;	1528	m_terminator = true;
		1529	m_columnNumber = 0;
1525	goto start;	1530	goto start;
1526	case CharacterInvalid:	1531	case CharacterInvalid:
1527	m_lexErrorMessage = invalidCharacterMessage();	1532	m_lexErrorMessage = invalidCharacterMessage();
Lines 1544-1549 inSingleLineComment: a/Source/JavaScriptCore/parser/Lexer.cpp_sec7
1544	shiftLineTerminator();	1549	shiftLineTerminator();
1545	m_atLineStart = true;	1550	m_atLineStart = true;
1546	m_terminator = true;	1551	m_terminator = true;
		1552	m_columnNumber = 0;
1547	if (!lastTokenWasRestrKeyword())	1553	if (!lastTokenWasRestrKeyword())
1548	goto start;	1554	goto start;
1549		1555
Lines 1551-1565 inSingleLineComment: a/Source/JavaScriptCore/parser/Lexer.cpp_sec8
1551	// Fall through into returnToken.	1557	// Fall through into returnToken.
1552		1558
1553	returnToken:	1559	returnToken:
1554	tokenInfo->line = m_lineNumber;	1560	tokenLocation->line = m_lineNumber;
1555	tokenInfo->endOffset = currentOffset();	1561	tokenLocation->endOffset = currentOffset();
1556	m_lastToken = token;	1562	m_lastToken = token;
1557	return token;	1563	return token;
1558		1564
1559	returnError:	1565	returnError:
1560	m_error = true;	1566	m_error = true;
1561	tokenInfo->line = m_lineNumber;	1567	tokenLocation->line = m_lineNumber;
1562	tokenInfo->endOffset = currentOffset();	1568	tokenLocation->endOffset = currentOffset();
1563	return ERRORTOK;	1569	return ERRORTOK;
1564	}	1570	}
1565		1571

Lines 87-95 public: a/Source/JavaScriptCore/parser/Lexer.h_sec1
- a/Source/JavaScriptCore/parser/Lexer.h -7 / +11 lines
87	void setIsReparsing() { m_isReparsing = true; }	87	void setIsReparsing() { m_isReparsing = true; }
88	bool isReparsing() const { return m_isReparsing; }	88	bool isReparsing() const { return m_isReparsing; }
89		89
90	JSTokenType lex(JSTokenData, JSTokenInfo, unsigned, bool strictMode);	90	JSTokenType lex(JSTokenData, JSTokenLocation, unsigned, bool strictMode);
91	bool nextTokenIsColon();	91	bool nextTokenIsColon();
92	int lineNumber() const { return m_lineNumber; }	92	int lineNumber() const { return m_lineNumber; }
		93	int currentColumnNumber() const { return m_columnNumber; }
93	void setLastLineNumber(int lastLineNumber) { m_lastLineNumber = lastLineNumber; }	94	void setLastLineNumber(int lastLineNumber) { m_lastLineNumber = lastLineNumber; }
94	int lastLineNumber() const { return m_lastLineNumber; }	95	int lastLineNumber() const { return m_lastLineNumber; }
95	bool prevTerminator() const { return m_terminator; }	96	bool prevTerminator() const { return m_terminator; }
Lines 120-126 public: a/Source/JavaScriptCore/parser/Lexer.h_sec2
120		121
121	SourceProvider* sourceProvider() const { return m_source->provider(); }	122	SourceProvider* sourceProvider() const { return m_source->provider(); }
122		123
123	JSTokenType lexExpectIdentifier(JSTokenData, JSTokenInfo, unsigned, bool strictMode);	124	JSTokenType lexExpectIdentifier(JSTokenData, JSTokenLocation, unsigned, bool strictMode);
124		125
125	private:	126	private:
126	void record8(int);	127	void record8(int);
Lines 166-171 private: a/Source/JavaScriptCore/parser/Lexer.h_sec3
166		167
167	int m_lineNumber;	168	int m_lineNumber;
168	int m_lastLineNumber;	169	int m_lastLineNumber;
		170	int m_columnNumber;
169		171
170	Vector<LChar> m_buffer8;	172	Vector<LChar> m_buffer8;
171	Vector<UChar> m_buffer16;	173	Vector<UChar> m_buffer16;
Lines 257-263 ALWAYS_INLINE const Identifier* Lexer<T>::makeIdentifierLCharFromUChar(const UCh a/Source/JavaScriptCore/parser/Lexer.h_sec4
257	}	259	}
258		260
259	template <typename T>	261	template <typename T>
260	ALWAYS_INLINE JSTokenType Lexer<T>::lexExpectIdentifier(JSTokenData* tokenData, JSTokenInfo* tokenInfo, unsigned lexerFlags, bool strictMode)	262	ALWAYS_INLINE JSTokenType Lexer<T>::lexExpectIdentifier(JSTokenData* tokenData, JSTokenLocation* tokenLocation, unsigned lexerFlags, bool strictMode)
261	{	263	{
262	ASSERT((lexerFlags & LexerFlagsIgnoreReservedWords));	264	ASSERT((lexerFlags & LexerFlagsIgnoreReservedWords));
263	const T* start = m_code;	265	const T* start = m_code;
Lines 285-304 ALWAYS_INLINE JSTokenType Lexer<T>::lexExpectIdentifier(JSTokenData* tokenData, a/Source/JavaScriptCore/parser/Lexer.h_sec5
285	m_current = 0;	287	m_current = 0;
286		288
287	m_code = ptr;	289	m_code = ptr;
		290	m_columnNumber = m_columnNumber + (m_code - start);
288		291
289	// Create the identifier if needed	292	// Create the identifier if needed
290	if (lexerFlags & LexexFlagsDontBuildKeywords)	293	if (lexerFlags & LexexFlagsDontBuildKeywords)
291	tokenData->ident = 0;	294	tokenData->ident = 0;
292	else	295	else
293	tokenData->ident = makeIdentifier(start, ptr - start);	296	tokenData->ident = makeIdentifier(start, ptr - start);
294	tokenInfo->line = m_lineNumber;	297	tokenLocation->line = m_lineNumber;
295	tokenInfo->startOffset = start - m_codeStart;	298	tokenLocation->startOffset = start - m_codeStart;
296	tokenInfo->endOffset = currentOffset();	299	tokenLocation->endOffset = currentOffset();
		300	tokenLocation->column = m_columnNumber;
297	m_lastToken = IDENT;	301	m_lastToken = IDENT;
298	return IDENT;	302	return IDENT;
299		303
300	slowCase:	304	slowCase:
301	return lex(tokenData, tokenInfo, lexerFlags, strictMode);	305	return lex(tokenData, tokenLocation, lexerFlags, strictMode);
302	}	306	}
303		307
304	} // namespace JSC	308	} // namespace JSC

Lines 52-61 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.cpp_sec1
- a/Source/JavaScriptCore/parser/Nodes.cpp -20 / +28 lines
52		52
53	// ------------------------------ StatementNode --------------------------------	53	// ------------------------------ StatementNode --------------------------------
54		54
		55	void StatementNode::setLoc(int firstLine, int lastLine, int column)
		56	{
		57	m_lineNumber = firstLine;
		58	m_lastLine = lastLine;
		59	m_columnNumber = column;
		60	}
		61
55	void StatementNode::setLoc(int firstLine, int lastLine)	62	void StatementNode::setLoc(int firstLine, int lastLine)
56	{	63	{
57	m_lineNumber = firstLine;	64	m_lineNumber = firstLine;
58	m_lastLine = lastLine;	65	m_lastLine = lastLine;
		66	m_columnNumber = 0;
59	}	67	}
60		68
61	// ------------------------------ SourceElements --------------------------------	69	// ------------------------------ SourceElements --------------------------------
Lines 75-82 StatementNode* SourceElements::singleStatement() const a/Source/JavaScriptCore/parser/Nodes.cpp_sec2
75		83
76	// ------------------------------ ScopeNode -----------------------------	84	// ------------------------------ ScopeNode -----------------------------
77		85
78	ScopeNode::ScopeNode(JSGlobalData* globalData, int lineNumber, bool inStrictContext)	86	ScopeNode::ScopeNode(JSGlobalData* globalData, const JSTokenLocation& location, bool inStrictContext)
79	: StatementNode(lineNumber)	87	: StatementNode(location)
80	, ParserArenaRefCounted(globalData)	88	, ParserArenaRefCounted(globalData)
81	, m_features(inStrictContext ? StrictModeFeature : NoFeatures)	89	, m_features(inStrictContext ? StrictModeFeature : NoFeatures)
82	, m_numConstants(0)	90	, m_numConstants(0)
Lines 84-91 ScopeNode::ScopeNode(JSGlobalData* globalData, int lineNumber, bool inStrictCont a/Source/JavaScriptCore/parser/Nodes.cpp_sec3
84	{	92	{
85	}	93	}
86		94
87	ScopeNode::ScopeNode(JSGlobalData* globalData, int lineNumber, const SourceCode& source, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, CodeFeatures features, int numConstants)	95	ScopeNode::ScopeNode(JSGlobalData* globalData, const JSTokenLocation& location, const SourceCode& source, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, CodeFeatures features, int numConstants)
88	: StatementNode(lineNumber)	96	: StatementNode(location)
89	, ParserArenaRefCounted(globalData)	97	, ParserArenaRefCounted(globalData)
90	, m_features(features)	98	, m_features(features)
91	, m_source(source)	99	, m_source(source)
Lines 107-120 StatementNode* ScopeNode::singleStatement() const a/Source/JavaScriptCore/parser/Nodes.cpp_sec4
107		115
108	// ------------------------------ ProgramNode -----------------------------	116	// ------------------------------ ProgramNode -----------------------------
109		117
110	inline ProgramNode::ProgramNode(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)	118	inline ProgramNode::ProgramNode(JSGlobalData* globalData, const JSTokenLocation& location, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
111	: ScopeNode(globalData, lineNumber, source, children, varStack, funcStack, capturedVariables, features, numConstants)	119	: ScopeNode(globalData, location, source, children, varStack, funcStack, capturedVariables, features, numConstants)
112	{	120	{
113	}	121	}
114		122
115	PassRefPtr<ProgramNode> ProgramNode::create(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)	123	PassRefPtr<ProgramNode> ProgramNode::create(JSGlobalData* globalData, const JSTokenLocation& location, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
116	{	124	{
117	RefPtr<ProgramNode> node = new ProgramNode(globalData, lineNumber, children, varStack, funcStack, capturedVariables, source, features, numConstants);	125	RefPtr<ProgramNode> node = new ProgramNode(globalData, location, children, varStack, funcStack, capturedVariables, source, features, numConstants);
118		126
119	ASSERT(node->m_arena.last() == node);	127	ASSERT(node->m_arena.last() == node);
120	node->m_arena.removeLast();	128	node->m_arena.removeLast();
Lines 125-138 PassRefPtr<ProgramNode> ProgramNode::create(JSGlobalData* globalData, int lineNu a/Source/JavaScriptCore/parser/Nodes.cpp_sec5
125		133
126	// ------------------------------ EvalNode -----------------------------	134	// ------------------------------ EvalNode -----------------------------
127		135
128	inline EvalNode::EvalNode(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)	136	inline EvalNode::EvalNode(JSGlobalData* globalData, const JSTokenLocation& location, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
129	: ScopeNode(globalData, lineNumber, source, children, varStack, funcStack, capturedVariables, features, numConstants)	137	: ScopeNode(globalData, location, source, children, varStack, funcStack, capturedVariables, features, numConstants)
130	{	138	{
131	}	139	}
132		140
133	PassRefPtr<EvalNode> EvalNode::create(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)	141	PassRefPtr<EvalNode> EvalNode::create(JSGlobalData* globalData, const JSTokenLocation& location, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
134	{	142	{
135	RefPtr<EvalNode> node = new EvalNode(globalData, lineNumber, children, varStack, funcStack, capturedVariables, source, features, numConstants);	143	RefPtr<EvalNode> node = new EvalNode(globalData, location, children, varStack, funcStack, capturedVariables, source, features, numConstants);
136		144
137	ASSERT(node->m_arena.last() == node);	145	ASSERT(node->m_arena.last() == node);
138	node->m_arena.removeLast();	146	node->m_arena.removeLast();
Lines 149-161 FunctionParameters::FunctionParameters(ParameterNode* firstParameter) a/Source/JavaScriptCore/parser/Nodes.cpp_sec6
149	append(parameter->ident());	157	append(parameter->ident());
150	}	158	}
151		159
152	inline FunctionBodyNode::FunctionBodyNode(JSGlobalData* globalData, int lineNumber, bool inStrictContext)	160	inline FunctionBodyNode::FunctionBodyNode(JSGlobalData* globalData, const JSTokenLocation& location, bool inStrictContext)
153	: ScopeNode(globalData, lineNumber, inStrictContext)	161	: ScopeNode(globalData, location, inStrictContext)
154	{	162	{
155	}	163	}
156		164
157	inline FunctionBodyNode::FunctionBodyNode(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& sourceCode, CodeFeatures features, int numConstants)	165	inline FunctionBodyNode::FunctionBodyNode(JSGlobalData* globalData, const JSTokenLocation& location, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& sourceCode, CodeFeatures features, int numConstants)
158	: ScopeNode(globalData, lineNumber, sourceCode, children, varStack, funcStack, capturedVariables, features, numConstants)	166	: ScopeNode(globalData, location, sourceCode, children, varStack, funcStack, capturedVariables, features, numConstants)
159	{	167	{
160	}	168	}
161		169
Lines 172-185 void FunctionBodyNode::finishParsing(PassRefPtr<FunctionParameters> parameters, a/Source/JavaScriptCore/parser/Nodes.cpp_sec7
172	m_ident = ident;	180	m_ident = ident;
173	}	181	}
174		182
175	FunctionBodyNode* FunctionBodyNode::create(JSGlobalData* globalData, int lineNumber, bool inStrictContext)	183	FunctionBodyNode* FunctionBodyNode::create(JSGlobalData* globalData, const JSTokenLocation& location, bool inStrictContext)
176	{	184	{
177	return new FunctionBodyNode(globalData, lineNumber, inStrictContext);	185	return new FunctionBodyNode(globalData, location, inStrictContext);
178	}	186	}
179		187
180	PassRefPtr<FunctionBodyNode> FunctionBodyNode::create(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& sourceCode, CodeFeatures features, int numConstants)	188	PassRefPtr<FunctionBodyNode> FunctionBodyNode::create(JSGlobalData* globalData, const JSTokenLocation& location, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& sourceCode, CodeFeatures features, int numConstants)
181	{	189	{
182	RefPtr<FunctionBodyNode> node = new FunctionBodyNode(globalData, lineNumber, children, varStack, funcStack, capturedVariables, sourceCode, features, numConstants);	190	RefPtr<FunctionBodyNode> node = new FunctionBodyNode(globalData, location, children, varStack, funcStack, capturedVariables, sourceCode, features, numConstants);
183		191
184	ASSERT(node->m_arena.last() == node);	192	ASSERT(node->m_arena.last() == node);
185	node->m_arena.removeLast();	193	node->m_arena.removeLast();

Lines 502-519 private: a/Source/JavaScriptCore/parser/Parser.h_sec1
- a/Source/JavaScriptCore/parser/Parser.h -12 / +20 lines
502		502
503	ALWAYS_INLINE void next(unsigned lexerFlags = 0)	503	ALWAYS_INLINE void next(unsigned lexerFlags = 0)
504	{	504	{
505	m_lastLine = m_token.m_info.line;	505	m_lastLine = m_token.m_location.line;
506	m_lastTokenEnd = m_token.m_info.endOffset;	506	m_lastTokenEnd = m_token.m_location.endOffset;
507	m_lexer->setLastLineNumber(m_lastLine);	507	m_lexer->setLastLineNumber(m_lastLine);
508	m_token.m_type = m_lexer->lex(&m_token.m_data, &m_token.m_info, lexerFlags, strictMode());	508	m_token.m_type = m_lexer->lex(&m_token.m_data, &m_token.m_location, lexerFlags, strictMode());
509	}	509	}
510		510
511	ALWAYS_INLINE void nextExpectIdentifier(unsigned lexerFlags = 0)	511	ALWAYS_INLINE void nextExpectIdentifier(unsigned lexerFlags = 0)
512	{	512	{
513	m_lastLine = m_token.m_info.line;	513	m_lastLine = m_token.m_location.line;
514	m_lastTokenEnd = m_token.m_info.endOffset;	514	m_lastTokenEnd = m_token.m_location.endOffset;
515	m_lexer->setLastLineNumber(m_lastLine);	515	m_lexer->setLastLineNumber(m_lastLine);
516	m_token.m_type = m_lexer->lexExpectIdentifier(&m_token.m_data, &m_token.m_info, lexerFlags, strictMode());	516	m_token.m_type = m_lexer->lexExpectIdentifier(&m_token.m_data, &m_token.m_location, lexerFlags, strictMode());
517	}	517	}
518		518
519	ALWAYS_INLINE bool nextTokenIsColon()	519	ALWAYS_INLINE bool nextTokenIsColon()
Lines 541-560 private: a/Source/JavaScriptCore/parser/Parser.h_sec2
541		541
542	ALWAYS_INLINE int tokenStart()	542	ALWAYS_INLINE int tokenStart()
543	{	543	{
544	return m_token.m_info.startOffset;	544	return m_token.m_location.startOffset;
545	}	545	}
546		546
547	ALWAYS_INLINE int tokenLine()	547	ALWAYS_INLINE int tokenLine()
548	{	548	{
549	return m_token.m_info.line;	549	return m_token.m_location.line;
550	}	550	}
551		551
552	ALWAYS_INLINE int tokenEnd()	552	ALWAYS_INLINE int tokenEnd()
553	{	553	{
554	return m_token.m_info.endOffset;	554	return m_token.m_location.endOffset;
555	}	555	}
556		556
557	const char* getTokenName(JSTokenType tok)	557	ALWAYS_INLINE const JSTokenLocation& tokenLocation()
		558	{
		559	return m_token.m_location;
		560	}
		561
		562	const char* getTokenName(JSTokenType tok)
558	{	563	{
559	switch (tok) {	564	switch (tok) {
560	case NULLTOKEN:	565	case NULLTOKEN:
Lines 1003-1010 PassRefPtr<ParsedNode> Parser<LexerType>::parse(JSGlobalObject* lexicalGlobalObj a/Source/JavaScriptCore/parser/Parser.h_sec3
1003		1008
1004	RefPtr<ParsedNode> result;	1009	RefPtr<ParsedNode> result;
1005	if (m_sourceElements) {	1010	if (m_sourceElements) {
		1011	JSTokenLocation location;
		1012	location.line = m_lexer->lastLineNumber();
		1013	location.column = m_lexer->currentColumnNumber();
1006	result = ParsedNode::create(&lexicalGlobalObject->globalData(),	1014	result = ParsedNode::create(&lexicalGlobalObject->globalData(),
1007	m_lexer->lastLineNumber(),	1015	location,
1008	m_sourceElements,	1016	m_sourceElements,
1009	m_varDeclarations ? &m_varDeclarations->data : 0,	1017	m_varDeclarations ? &m_varDeclarations->data : 0,
1010	m_funcDeclarations ? &m_funcDeclarations->data : 0,	1018	m_funcDeclarations ? &m_funcDeclarations->data : 0,
Lines 1012-1018 PassRefPtr<ParsedNode> Parser<LexerType>::parse(JSGlobalObject* lexicalGlobalObj a/Source/JavaScriptCore/parser/Parser.h_sec4
1012	*m_source,	1020	*m_source,
1013	m_features,	1021	m_features,
1014	m_numConstants);	1022	m_numConstants);
1015	result->setLoc(m_source->firstLine(), m_lastLine);	1023	result->setLoc(m_source->firstLine(), m_lastLine, m_lexer->currentColumnNumber());
1016	} else if (lexicalGlobalObject) {	1024	} else if (lexicalGlobalObject) {
1017	// We can never see a syntax error when reparsing a function, since we should have	1025	// We can never see a syntax error when reparsing a function, since we should have
1018	// reported the error when parsing the containing program or eval code. So if we're	1026	// reported the error when parsing the containing program or eval code. So if we're

Lines 140-156 union JSTokenData { a/Source/JavaScriptCore/parser/ParserTokens.h_sec1
- a/Source/JavaScriptCore/parser/ParserTokens.h -3 / +11 lines
140	const Identifier* ident;	140	const Identifier* ident;
141	};	141	};
142		142
143	struct JSTokenInfo {	143	struct JSTokenLocation {
144	JSTokenInfo() : line(0) { }	144	JSTokenLocation() : line(0), column(0) { }
		145	JSTokenLocation(const JSTokenLocation& location)
		146	{
		147	line = location.line;
		148	startOffset = location.startOffset;
		149	endOffset = location.endOffset;
		150	column = location.column;
		151	}
145	int line;	152	int line;
146	int startOffset;	153	int startOffset;
147	int endOffset;	154	int endOffset;
		155	int column;
148	};	156	};
149		157
150	struct JSToken {	158	struct JSToken {
151	JSTokenType m_type;	159	JSTokenType m_type;
152	JSTokenData m_data;	160	JSTokenData m_data;
153	JSTokenInfo m_info;	161	JSTokenLocation m_location;
154	};	162	};
155		163
156	enum JSParserStrictness { JSParseNormal, JSParseStrict };	164	enum JSParserStrictness { JSParseNormal, JSParseStrict };

Lines 53-61 public: a/Source/JavaScriptCore/parser/SourceProviderCacheItem.h_sec1
- a/Source/JavaScriptCore/parser/SourceProviderCacheItem.h -3 / +3 lines
53	JSToken token;	53	JSToken token;
54	token.m_type = CLOSEBRACE;	54	token.m_type = CLOSEBRACE;
55	token.m_data.intValue = closeBracePos;	55	token.m_data.intValue = closeBracePos;
56	token.m_info.startOffset = closeBracePos;	56	token.m_location.startOffset = closeBracePos;
57	token.m_info.endOffset = closeBracePos + 1;	57	token.m_location.endOffset = closeBracePos + 1;
58	token.m_info.line = closeBraceLine;	58	token.m_location.line = closeBraceLine;
59	return token;	59	return token;
60	}	60	}
61		61

Lines 119-160 public: a/Source/JavaScriptCore/parser/SyntaxChecker.h_sec1
- a/Source/JavaScriptCore/parser/SyntaxChecker.h -65 / +65 lines
119	static const unsigned DontBuildStrings = LexerFlagsDontBuildStrings;	119	static const unsigned DontBuildStrings = LexerFlagsDontBuildStrings;
120		120
121	int createSourceElements() { return 1; }	121	int createSourceElements() { return 1; }
122	ExpressionType makeFunctionCallNode(int, int, int, int, int, int) { return CallExpr; }	122	ExpressionType makeFunctionCallNode(const JSTokenLocation&, int, int, int, int, int) { return CallExpr; }
123	void appendToComma(ExpressionType& base, ExpressionType right) { base = right; }	123	void appendToComma(ExpressionType& base, ExpressionType right) { base = right; }
124	ExpressionType createCommaExpr(int, ExpressionType, ExpressionType right) { return right; }	124	ExpressionType createCommaExpr(const JSTokenLocation&, ExpressionType, ExpressionType right) { return right; }
125	ExpressionType makeAssignNode(int, ExpressionType, Operator, ExpressionType, bool, bool, int, int, int) { return AssignmentExpr; }	125	ExpressionType makeAssignNode(const JSTokenLocation&, ExpressionType, Operator, ExpressionType, bool, bool, int, int, int) { return AssignmentExpr; }
126	ExpressionType makePrefixNode(int, ExpressionType, Operator, int, int, int) { return PreExpr; }	126	ExpressionType makePrefixNode(const JSTokenLocation&, ExpressionType, Operator, int, int, int) { return PreExpr; }
127	ExpressionType makePostfixNode(int, ExpressionType, Operator, int, int, int) { return PostExpr; }	127	ExpressionType makePostfixNode(const JSTokenLocation&, ExpressionType, Operator, int, int, int) { return PostExpr; }
128	ExpressionType makeTypeOfNode(int, ExpressionType) { return TypeofExpr; }	128	ExpressionType makeTypeOfNode(const JSTokenLocation&, ExpressionType) { return TypeofExpr; }
129	ExpressionType makeDeleteNode(int, ExpressionType, int, int, int) { return DeleteExpr; }	129	ExpressionType makeDeleteNode(const JSTokenLocation&, ExpressionType, int, int, int) { return DeleteExpr; }
130	ExpressionType makeNegateNode(int, ExpressionType) { return UnaryExpr; }	130	ExpressionType makeNegateNode(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
131	ExpressionType makeBitwiseNotNode(int, ExpressionType) { return UnaryExpr; }	131	ExpressionType makeBitwiseNotNode(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
132	ExpressionType createLogicalNot(int, ExpressionType) { return UnaryExpr; }	132	ExpressionType createLogicalNot(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
133	ExpressionType createUnaryPlus(int, ExpressionType) { return UnaryExpr; }	133	ExpressionType createUnaryPlus(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
134	ExpressionType createVoid(int, ExpressionType) { return UnaryExpr; }	134	ExpressionType createVoid(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
135	ExpressionType thisExpr(int) { return ThisExpr; }	135	ExpressionType thisExpr(const JSTokenLocation&) { return ThisExpr; }
136	ExpressionType createResolve(int, const Identifier*, int) { return ResolveExpr; }	136	ExpressionType createResolve(const JSTokenLocation&, const Identifier*, int) { return ResolveExpr; }
137	ExpressionType createObjectLiteral(int) { return ObjectLiteralExpr; }	137	ExpressionType createObjectLiteral(const JSTokenLocation&) { return ObjectLiteralExpr; }
138	ExpressionType createObjectLiteral(int, int) { return ObjectLiteralExpr; }	138	ExpressionType createObjectLiteral(const JSTokenLocation&, int) { return ObjectLiteralExpr; }
139	ExpressionType createArray(int, int) { return ArrayLiteralExpr; }	139	ExpressionType createArray(const JSTokenLocation&, int) { return ArrayLiteralExpr; }
140	ExpressionType createArray(int, int, int) { return ArrayLiteralExpr; }	140	ExpressionType createArray(const JSTokenLocation&, int, int) { return ArrayLiteralExpr; }
141	ExpressionType createNumberExpr(int, double) { return NumberExpr; }	141	ExpressionType createNumberExpr(const JSTokenLocation&, double) { return NumberExpr; }
142	ExpressionType createString(int, const Identifier*) { return StringExpr; }	142	ExpressionType createString(const JSTokenLocation&, const Identifier*) { return StringExpr; }
143	ExpressionType createBoolean(int, bool) { return BoolExpr; }	143	ExpressionType createBoolean(const JSTokenLocation&, bool) { return BoolExpr; }
144	ExpressionType createNull(int) { return NullExpr; }	144	ExpressionType createNull(const JSTokenLocation&) { return NullExpr; }
145	ExpressionType createBracketAccess(int, ExpressionType, ExpressionType, bool, int, int, int) { return BracketExpr; }	145	ExpressionType createBracketAccess(const JSTokenLocation&, ExpressionType, ExpressionType, bool, int, int, int) { return BracketExpr; }
146	ExpressionType createDotAccess(int, ExpressionType, const Identifier*, int, int, int) { return DotExpr; }	146	ExpressionType createDotAccess(const JSTokenLocation&, ExpressionType, const Identifier*, int, int, int) { return DotExpr; }
147	ExpressionType createRegExp(int, const Identifier& pattern, const Identifier&, int) { return Yarr::checkSyntax(pattern.ustring()) ? 0 : RegExpExpr; }	147	ExpressionType createRegExp(const JSTokenLocation&, const Identifier& pattern, const Identifier&, int) { return Yarr::checkSyntax(pattern.ustring()) ? 0 : RegExpExpr; }
148	ExpressionType createNewExpr(int, ExpressionType, int, int, int, int) { return NewExpr; }	148	ExpressionType createNewExpr(const JSTokenLocation&, ExpressionType, int, int, int, int) { return NewExpr; }
149	ExpressionType createNewExpr(int, ExpressionType, int, int) { return NewExpr; }	149	ExpressionType createNewExpr(const JSTokenLocation&, ExpressionType, int, int) { return NewExpr; }
150	ExpressionType createConditionalExpr(int, ExpressionType, ExpressionType, ExpressionType) { return ConditionalExpr; }	150	ExpressionType createConditionalExpr(const JSTokenLocation&, ExpressionType, ExpressionType, ExpressionType) { return ConditionalExpr; }
151	ExpressionType createAssignResolve(int, const Identifier&, ExpressionType, int, int, int) { return AssignmentExpr; }	151	ExpressionType createAssignResolve(const JSTokenLocation&, const Identifier&, ExpressionType, int, int, int) { return AssignmentExpr; }
152	ExpressionType createFunctionExpr(int, const Identifier*, int, int, int, int, int, int) { return FunctionExpr; }	152	ExpressionType createFunctionExpr(const JSTokenLocation&, const Identifier*, int, int, int, int, int, int) { return FunctionExpr; }
153	int createFunctionBody(int, bool) { return 1; }	153	int createFunctionBody(const JSTokenLocation&, bool) { return 1; }
154	int createArguments() { return 1; }	154	int createArguments() { return 1; }
155	int createArguments(int) { return 1; }	155	int createArguments(int) { return 1; }
156	int createArgumentsList(int, int) { return 1; }	156	int createArgumentsList(const JSTokenLocation&, int) { return 1; }
157	int createArgumentsList(int, int, int) { return 1; }	157	int createArgumentsList(const JSTokenLocation&, int, int) { return 1; }
158	template <bool complete> Property createProperty(const Identifier* name, int, PropertyNode::Type type)	158	template <bool complete> Property createProperty(const Identifier* name, int, PropertyNode::Type type)
159	{	159	{
160	if (!complete)	160	if (!complete)
Lines 168-175 public: a/Source/JavaScriptCore/parser/SyntaxChecker.h_sec2
168	return Property(type);	168	return Property(type);
169	return Property(&globalData->parserArena->identifierArena().makeNumericIdentifier(globalData, name), type);	169	return Property(&globalData->parserArena->identifierArena().makeNumericIdentifier(globalData, name), type);
170	}	170	}
171	int createPropertyList(int, Property) { return 1; }	171	int createPropertyList(const JSTokenLocation&, Property) { return 1; }
172	int createPropertyList(int, Property, int) { return 1; }	172	int createPropertyList(const JSTokenLocation&, Property, int) { return 1; }
173	int createElementList(int, int) { return 1; }	173	int createElementList(int, int) { return 1; }
174	int createElementList(int, int, int) { return 1; }	174	int createElementList(int, int, int) { return 1; }
175	int createFormalParameterList(const Identifier&) { return 1; }	175	int createFormalParameterList(const Identifier&) { return 1; }
Lines 178-216 public: a/Source/JavaScriptCore/parser/SyntaxChecker.h_sec3
178	int createClauseList(int) { return 1; }	178	int createClauseList(int) { return 1; }
179	int createClauseList(int, int) { return 1; }	179	int createClauseList(int, int) { return 1; }
180	void setUsesArguments(int) { }	180	void setUsesArguments(int) { }
181	int createFuncDeclStatement(int, const Identifier*, int, int, int, int, int, int) { return 1; }	181	int createFuncDeclStatement(const JSTokenLocation&, const Identifier*, int, int, int, int, int, int) { return 1; }
182	int createBlockStatement(int, int, int, int) { return 1; }	182	int createBlockStatement(const JSTokenLocation&, int, int, int) { return 1; }
183	int createExprStatement(int, int, int, int) { return 1; }	183	int createExprStatement(const JSTokenLocation&, int, int, int) { return 1; }
184	int createIfStatement(int, int, int, int, int) { return 1; }	184	int createIfStatement(const JSTokenLocation&, int, int, int, int) { return 1; }
185	int createIfStatement(int, int, int, int, int, int) { return 1; }	185	int createIfStatement(const JSTokenLocation&, int, int, int, int, int) { return 1; }
186	int createForLoop(int, int, int, int, int, int, int) { return 1; }	186	int createForLoop(const JSTokenLocation&, int, int, int, int, int, int) { return 1; }
187	int createForInLoop(int, const Identifier*, int, int, int, int, int, int, int, int, int, int) { return 1; }	187	int createForInLoop(const JSTokenLocation&, const Identifier*, int, int, int, int, int, int, int, int, int, int) { return 1; }
188	int createForInLoop(int, int, int, int, int, int, int, int, int) { return 1; }	188	int createForInLoop(const JSTokenLocation&, int, int, int, int, int, int, int, int) { return 1; }
189	int createEmptyStatement(int) { return 1; }	189	int createEmptyStatement(const JSTokenLocation&) { return 1; }
190	int createVarStatement(int, int, int, int) { return 1; }	190	int createVarStatement(const JSTokenLocation&, int, int, int) { return 1; }
191	int createReturnStatement(int, int, int, int, int, int) { return 1; }	191	int createReturnStatement(const JSTokenLocation&, int, int, int, int, int) { return 1; }
192	int createBreakStatement(int, int, int, int, int) { return 1; }	192	int createBreakStatement(const JSTokenLocation&, int, int, int, int) { return 1; }
193	int createBreakStatement(int, const Identifier*, int, int, int, int) { return 1; }	193	int createBreakStatement(const JSTokenLocation&, const Identifier*, int, int, int, int) { return 1; }
194	int createContinueStatement(int, int, int, int, int) { return 1; }	194	int createContinueStatement(const JSTokenLocation&, int, int, int, int) { return 1; }
195	int createContinueStatement(int, const Identifier*, int, int, int, int) { return 1; }	195	int createContinueStatement(const JSTokenLocation&, const Identifier*, int, int, int, int) { return 1; }
196	int createTryStatement(int, int, const Identifier*, int, int, int, int) { return 1; }	196	int createTryStatement(const JSTokenLocation&, int, const Identifier*, int, int, int, int) { return 1; }
197	int createSwitchStatement(int, int, int, int, int, int, int) { return 1; }	197	int createSwitchStatement(const JSTokenLocation&, int, int, int, int, int, int) { return 1; }
198	int createWhileStatement(int, int, int, int, int) { return 1; }	198	int createWhileStatement(const JSTokenLocation&, int, int, int, int) { return 1; }
199	int createWithStatement(int, int, int, int, int, int, int) { return 1; }	199	int createWithStatement(const JSTokenLocation&, int, int, int, int, int, int) { return 1; }
200	int createDoWhileStatement(int, int, int, int, int) { return 1; }	200	int createDoWhileStatement(const JSTokenLocation&, int, int, int, int) { return 1; }
201	int createLabelStatement(int, const Identifier*, int, int, int) { return 1; }	201	int createLabelStatement(const JSTokenLocation&, const Identifier*, int, int, int) { return 1; }
202	int createThrowStatement(int, int, int, int, int, int) { return 1; }	202	int createThrowStatement(const JSTokenLocation&, int, int, int, int, int) { return 1; }
203	int createDebugger(int, int, int) { return 1; }	203	int createDebugger(const JSTokenLocation&, int, int) { return 1; }
204	int createConstStatement(int, int, int, int) { return 1; }	204	int createConstStatement(const JSTokenLocation&, int, int, int) { return 1; }
205	int appendConstDecl(int, int, const Identifier*, int) { return 1; }	205	int appendConstDecl(const JSTokenLocation&, int, const Identifier*, int) { return 1; }
206	template <bool strict> Property createGetterOrSetterProperty(int, PropertyNode::Type type, const Identifier* name, int, int, int, int, int, int)	206	template <bool strict> Property createGetterOrSetterProperty(const JSTokenLocation&, PropertyNode::Type type, const Identifier* name, int, int, int, int, int, int)
207	{	207	{
208	ASSERT(name);	208	ASSERT(name);
209	if (!strict)	209	if (!strict)
210	return Property(type);	210	return Property(type);
211	return Property(name, type);	211	return Property(name, type);
212	}	212	}
213	template <bool strict> Property createGetterOrSetterProperty(JSGlobalData* globalData, int, PropertyNode::Type type, double name, int, int, int, int, int, int)	213	template <bool strict> Property createGetterOrSetterProperty(JSGlobalData* globalData, const JSTokenLocation&, PropertyNode::Type type, double name, int, int, int, int, int, int)
214	{	214	{
215	if (!strict)	215	if (!strict)
216	return Property(type);	216	return Property(type);
Lines 219-225 public: a/Source/JavaScriptCore/parser/SyntaxChecker.h_sec4
219		219
220	void appendStatement(int, int) { }	220	void appendStatement(int, int) { }
221	void addVar(const Identifier*, bool) { }	221	void addVar(const Identifier*, bool) { }
222	int combineCommaNodes(int, int, int) { return 1; }	222	int combineCommaNodes(const JSTokenLocation&, int, int) { return 1; }
223	int evalCount() const { return 0; }	223	int evalCount() const { return 0; }
224	void appendBinaryExpressionInfo(int& operandStackDepth, int expr, int, int, int, bool)	224	void appendBinaryExpressionInfo(int& operandStackDepth, int expr, int, int, int, bool)
225	{	225	{
Lines 235-241 public: a/Source/JavaScriptCore/parser/SyntaxChecker.h_sec5
235	bool operatorStackHasHigherPrecedence(int&, int) { return true; }	235	bool operatorStackHasHigherPrecedence(int&, int) { return true; }
236	BinaryOperand getFromOperandStack(int) { return m_topBinaryExpr; }	236	BinaryOperand getFromOperandStack(int) { return m_topBinaryExpr; }
237	void shrinkOperandStackBy(int& operandStackDepth, int amount) { operandStackDepth -= amount; }	237	void shrinkOperandStackBy(int& operandStackDepth, int amount) { operandStackDepth -= amount; }
238	void appendBinaryOperation(int, int& operandStackDepth, int&, BinaryOperand, BinaryOperand) { operandStackDepth++; }	238	void appendBinaryOperation(const JSTokenLocation&, int& operandStackDepth, int&, BinaryOperand, BinaryOperand) { operandStackDepth++; }
239	void operatorStackAppend(int& operatorStackDepth, int, int) { operatorStackDepth++; }	239	void operatorStackAppend(int& operatorStackDepth, int, int) { operatorStackDepth++; }
240	int popOperandStack(int&) { int res = m_topBinaryExpr; m_topBinaryExpr = 0; return res; }	240	int popOperandStack(int&) { int res = m_topBinaryExpr; m_topBinaryExpr = 0; return res; }
241		241
Lines 245-251 public: a/Source/JavaScriptCore/parser/SyntaxChecker.h_sec6
245	void unaryTokenStackRemoveLast(int& stackDepth) { stackDepth = 0; }	245	void unaryTokenStackRemoveLast(int& stackDepth) { stackDepth = 0; }
246		246
247	void assignmentStackAppend(int, int, int, int, int, Operator) { }	247	void assignmentStackAppend(int, int, int, int, int, Operator) { }
248	int createAssignment(int, int, int, int, int, int) { ASSERT_NOT_REACHED(); return 1; }	248	int createAssignment(const JSTokenLocation&, int, int, int, int, int) { ASSERT_NOT_REACHED(); return 1; }
249	const Identifier& getName(const Property& property) const { ASSERT(property.name); return *property.name; }	249	const Identifier& getName(const Property& property) const { ASSERT(property.name); return *property.name; }
250	PropertyNode::Type getType(const Property& property) const { return property.type; }	250	PropertyNode::Type getType(const Property& property) const { return property.type; }
251	bool isResolve(ExpressionType expr) const { return expr == ResolveExpr \|\| expr == ResolveEvalExpr; }	251	bool isResolve(ExpressionType expr) const { return expr == ResolveExpr \|\| expr == ResolveEvalExpr; }

Lines 75-94 String ScriptDebugServer::setBreakpoint(const String& sourceID, const ScriptBrea a/Source/WebCore/bindings/js/ScriptDebugServer.cpp_sec1
- a/Source/WebCore/bindings/js/ScriptDebugServer.cpp -26 / +141 lines
75	SourceIdToBreakpointsMap::iterator it = m_sourceIdToBreakpoints.find(sourceIDValue);	75	SourceIdToBreakpointsMap::iterator it = m_sourceIdToBreakpoints.find(sourceIDValue);
76	if (it == m_sourceIdToBreakpoints.end())	76	if (it == m_sourceIdToBreakpoints.end())
77	it = m_sourceIdToBreakpoints.set(sourceIDValue, LineToBreakpointMap()).iterator;	77	it = m_sourceIdToBreakpoints.set(sourceIDValue, LineToBreakpointMap()).iterator;
78	if (it->second.contains(scriptBreakpoint.lineNumber + 1))	78	LineToBreakpointMap::iterator breaksIt = it->second.find(scriptBreakpoint.lineNumber + 1);
79	return "";	79	if (breaksIt == it->second.end())
80	it->second.set(scriptBreakpoint.lineNumber + 1, scriptBreakpoint);	80	breaksIt = it->second.set(scriptBreakpoint.lineNumber + 1, BreakpointsInLine()).iterator;
		81
		82	BreakpointsInLine& breaksVector = breaksIt->second;
		83	unsigned breaksCount = breaksVector.size();
		84	for (unsigned i = 0; i < breaksCount; i++) {
		85	if (breaksVector.at(i).columnNumber == scriptBreakpoint.columnNumber)
		86	return "";
		87	}
		88	breaksVector.append(scriptBreakpoint);
		89
81	*actualLineNumber = scriptBreakpoint.lineNumber;	90	*actualLineNumber = scriptBreakpoint.lineNumber;
82	// FIXME(WK53003): implement setting breakpoints by line:column.	91	*actualColumnNumber = scriptBreakpoint.columnNumber;
83	*actualColumnNumber = 0;	92	return sourceID + ":" + String::number(scriptBreakpoint.lineNumber) + ":" + String::number(scriptBreakpoint.columnNumber);
84	return sourceID + ":" + String::number(scriptBreakpoint.lineNumber);
85	}	93	}
86		94
87	void ScriptDebugServer::removeBreakpoint(const String& breakpointId)	95	void ScriptDebugServer::removeBreakpoint(const String& breakpointId)
88	{	96	{
89	Vector<String> tokens;	97	Vector<String> tokens;
90	breakpointId.split(":", tokens);	98	breakpointId.split(":", tokens);
91	if (tokens.size() != 2)	99	if (tokens.size() != 3)
92	return;	100	return;
93	bool success;	101	bool success;
94	intptr_t sourceIDValue = tokens[0].toIntPtr(&success);	102	intptr_t sourceIDValue = tokens[0].toIntPtr(&success);
Lines 97-105 void ScriptDebugServer::removeBreakpoint(const String& breakpointId) a/Source/WebCore/bindings/js/ScriptDebugServer.cpp_sec2
97	unsigned lineNumber = tokens[1].toUInt(&success);	105	unsigned lineNumber = tokens[1].toUInt(&success);
98	if (!success)	106	if (!success)
99	return;	107	return;
		108	unsigned columnNumber = tokens[2].toUInt(&success);
		109	if (!success)
		110	return;
		111
100	SourceIdToBreakpointsMap::iterator it = m_sourceIdToBreakpoints.find(sourceIDValue);	112	SourceIdToBreakpointsMap::iterator it = m_sourceIdToBreakpoints.find(sourceIDValue);
101	if (it != m_sourceIdToBreakpoints.end())	113	if (it == m_sourceIdToBreakpoints.end())
102	it->second.remove(lineNumber + 1);	114	return;
		115	LineToBreakpointMap::iterator breaksIt = it->second.find(lineNumber + 1);
		116	if (breaksIt == it->second.end())
		117	return;
		118
		119	BreakpointsInLine& breaksVector = breaksIt->second;
		120	unsigned breaksCount = breaksVector.size();
		121	for (unsigned i = 0; i < breaksCount; i++) {
		122	if (breaksVector.at(i).columnNumber == static_cast<int>(columnNumber)) {
		123	breaksVector.remove(i);
		124	break;
		125	}
		126	}
		127	}
		128
		129	void ScriptDebugServer::updateCurrentStatementPosition(intptr_t sourceID, int line)
		130	{
		131	if (line < 0)
		132	return;
		133
		134	SourceProvider* source = reinterpret_cast<SourceProvider*>(sourceID);
		135
		136	if (m_currentSourceID != sourceID) {
		137	String sourceCode = ustringToString(JSC::UString(const_cast<StringImpl*>(source->data())));
		138	m_currentSourceCode.clear();
		139	sourceCode.split("\n", true, m_currentSourceCode);
		140	m_currentSourceID = sourceID;
		141	m_currentStatementPosition.lineNumber = 0;
		142	m_currentStatementPosition.columnNumber = 0;
		143	}
		144
		145	if (line != m_currentStatementPosition.lineNumber) {
		146	m_currentStatementPosition.lineNumber = line;
		147	m_currentStatementPosition.columnNumber = 0;
		148	return;
		149	}
		150
		151	int startLine = source->startPosition().m_line.zeroBasedInt();
		152	if ((m_currentStatementPosition.lineNumber - startLine - 1) >= static_cast<int>(m_currentSourceCode.size()))
		153	return;
		154	const String& codeInLine = m_currentSourceCode[m_currentStatementPosition.lineNumber - startLine - 1];
		155	if (codeInLine.isEmpty())
		156	return;
		157	int nextColumn = codeInLine.find(";", m_currentStatementPosition.columnNumber);
		158	if (nextColumn != -1) {
		159	UChar c = codeInLine[nextColumn + 1];
		160	if (c == ' ' \|\| c == '\t')
		161	nextColumn += 1;
		162	m_currentStatementPosition.columnNumber = nextColumn + 1;
		163	} else
		164	m_currentStatementPosition.columnNumber = 0;
103	}	165	}
104		166
105	bool ScriptDebugServer::hasBreakpoint(intptr_t sourceID, const TextPosition& position) const	167	bool ScriptDebugServer::hasBreakpoint(intptr_t sourceID, const TextPosition& position) const
Lines 110-128 bool ScriptDebugServer::hasBreakpoint(intptr_t sourceID, const TextPosition& pos a/Source/WebCore/bindings/js/ScriptDebugServer.cpp_sec3
110	SourceIdToBreakpointsMap::const_iterator it = m_sourceIdToBreakpoints.find(sourceID);	172	SourceIdToBreakpointsMap::const_iterator it = m_sourceIdToBreakpoints.find(sourceID);
111	if (it == m_sourceIdToBreakpoints.end())	173	if (it == m_sourceIdToBreakpoints.end())
112	return false;	174	return false;
113	int lineNumber = position.m_line.oneBasedInt();	175
114	if (lineNumber <= 0)	176	int lineNumber = position.m_line.zeroBasedInt();
		177	int columnNumber = position.m_column.zeroBasedInt();
		178	if (lineNumber < 0 \|\| columnNumber < 0)
		179	return false;
		180
		181	LineToBreakpointMap::const_iterator breaksIt = it->second.find(lineNumber + 1);
		182	if (breaksIt == it->second.end())
115	return false;	183	return false;
116	LineToBreakpointMap::const_iterator breakIt = it->second.find(lineNumber);	184
117	if (breakIt == it->second.end())	185	bool hit = false;
		186	const BreakpointsInLine& breaksVector = breaksIt->second;
		187	unsigned breaksCount = breaksVector.size();
		188	unsigned i;
		189	for (i = 0; i < breaksCount; i++) {
		190	int breakColumn = breaksVector.at(i).columnNumber;
		191	int breakLine = breaksVector.at(i).lineNumber;
		192	if (lineNumber == breakLine && columnNumber == breakColumn) {
		193	hit = true;
		194	break;
		195	}
		196	}
		197	if (!hit)
118	return false;	198	return false;
119		199
120	// An empty condition counts as no condition which is equivalent to "true".	200	// An empty condition counts as no condition which is equivalent to "true".
121	if (breakIt->second.condition.isEmpty())	201	if (breaksVector.at(i).condition.isEmpty())
122	return true;	202	return true;
123		203
124	JSValue exception;	204	JSValue exception;
125	JSValue result = m_currentCallFrame->evaluate(stringToUString(breakIt->second.condition), exception);	205	JSValue result = m_currentCallFrame->evaluate(stringToUString(breaksVector.at(i).condition), exception);
126	if (exception) {	206	if (exception) {
127	// An erroneous condition counts as "false".	207	// An erroneous condition counts as "false".
128	return false;	208	return false;
Lines 347-366 void ScriptDebugServer::dispatchFunctionToListeners(JavaScriptExecutionCallback a/Source/WebCore/bindings/js/ScriptDebugServer.cpp_sec4
347	m_callingListeners = false;	427	m_callingListeners = false;
348	}	428	}
349		429
350	void ScriptDebugServer::createCallFrameAndPauseIfNeeded(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)	430	void ScriptDebugServer::createCallFrameAndPauseIfNeeded(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber)
351	{	431	{
352	TextPosition textPosition(OrdinalNumber::fromOneBasedInt(lineNumber), OrdinalNumber::first());	432	TextPosition textPosition(OrdinalNumber::fromOneBasedInt(lineNumber), OrdinalNumber::fromZeroBasedInt(columnNumber));
353	m_currentCallFrame = JavaScriptCallFrame::create(debuggerCallFrame, m_currentCallFrame, sourceID, textPosition);	433	m_currentCallFrame = JavaScriptCallFrame::create(debuggerCallFrame, m_currentCallFrame, sourceID, textPosition);
354	pauseIfNeeded(debuggerCallFrame.dynamicGlobalObject());	434	pauseIfNeeded(debuggerCallFrame.dynamicGlobalObject());
355	}	435	}
356		436
357	void ScriptDebugServer::updateCallFrameAndPauseIfNeeded(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)	437	void ScriptDebugServer::updateCallFrameAndPauseIfNeeded(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber)
358	{	438	{
359	ASSERT(m_currentCallFrame);	439	ASSERT(m_currentCallFrame);
360	if (!m_currentCallFrame)	440	if (!m_currentCallFrame)
361	return;	441	return;
362		442
363	TextPosition textPosition(OrdinalNumber::fromOneBasedInt(lineNumber), OrdinalNumber::first());	443	TextPosition textPosition(OrdinalNumber::fromOneBasedInt(lineNumber), OrdinalNumber::fromZeroBasedInt(columnNumber));
364	m_currentCallFrame->update(debuggerCallFrame, sourceID, textPosition);	444	m_currentCallFrame->update(debuggerCallFrame, sourceID, textPosition);
365	pauseIfNeeded(debuggerCallFrame.dynamicGlobalObject());	445	pauseIfNeeded(debuggerCallFrame.dynamicGlobalObject());
366	}	446	}
Lines 401-422 void ScriptDebugServer::pauseIfNeeded(JSGlobalObject* dynamicGlobalObject) a/Source/WebCore/bindings/js/ScriptDebugServer.cpp_sec5
401		481
402	void ScriptDebugServer::callEvent(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)	482	void ScriptDebugServer::callEvent(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)
403	{	483	{
		484	callEvent(debuggerCallFrame, sourceID, lineNumber, 0);
		485	}
		486
		487	void ScriptDebugServer::callEvent(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber)
		488	{
404	if (!m_paused)	489	if (!m_paused)
405	createCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber);	490	createCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber, columnNumber);
406	}	491	}
407		492
408	void ScriptDebugServer::atStatement(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)	493	void ScriptDebugServer::atStatement(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)
409	{	494	{
		495	atStatement(debuggerCallFrame, sourceID, lineNumber, 0);
		496	}
		497
		498	void ScriptDebugServer::atStatement(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber)
		499	{
410	if (!m_paused)	500	if (!m_paused)
411	updateCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber);	501	updateCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber, columnNumber);
412	}	502	}
413		503
414	void ScriptDebugServer::returnEvent(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)	504	void ScriptDebugServer::returnEvent(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)
415	{	505	{
		506	returnEvent(debuggerCallFrame, sourceID, lineNumber, 0);
		507	}
		508
		509	void ScriptDebugServer::returnEvent(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber)
		510	{
416	if (m_paused)	511	if (m_paused)
417	return;	512	return;
418		513
419	updateCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber);	514	updateCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber, columnNumber);
420		515
421	// detach may have been called during pauseIfNeeded	516	// detach may have been called during pauseIfNeeded
422	if (!m_currentCallFrame)	517	if (!m_currentCallFrame)
Lines 430-456 void ScriptDebugServer::returnEvent(const DebuggerCallFrame& debuggerCallFrame, a/Source/WebCore/bindings/js/ScriptDebugServer.cpp_sec6
430		525
431	void ScriptDebugServer::exception(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, bool hasHandler)	526	void ScriptDebugServer::exception(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, bool hasHandler)
432	{	527	{
		528	exception(debuggerCallFrame, sourceID, lineNumber, 0, hasHandler);
		529	}
		530
		531	void ScriptDebugServer::exception(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber, bool hasHandler)
		532	{
433	if (m_paused)	533	if (m_paused)
434	return;	534	return;
435		535
436	if (m_pauseOnExceptionsState == PauseOnAllExceptions \|\| (m_pauseOnExceptionsState == PauseOnUncaughtExceptions && !hasHandler))	536	if (m_pauseOnExceptionsState == PauseOnAllExceptions \|\| (m_pauseOnExceptionsState == PauseOnUncaughtExceptions && !hasHandler))
437	m_pauseOnNextStatement = true;	537	m_pauseOnNextStatement = true;
438		538
439	updateCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber);	539	updateCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber, columnNumber);
440	}	540	}
441		541
442	void ScriptDebugServer::willExecuteProgram(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)	542	void ScriptDebugServer::willExecuteProgram(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)
443	{	543	{
		544	willExecuteProgram(debuggerCallFrame, sourceID, lineNumber, 0);
		545	}
		546
		547	void ScriptDebugServer::willExecuteProgram(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber)
		548	{
444	if (!m_paused)	549	if (!m_paused)
445	createCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber);	550	createCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber, columnNumber);
446	}	551	}
447		552
448	void ScriptDebugServer::didExecuteProgram(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)	553	void ScriptDebugServer::didExecuteProgram(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)
449	{	554	{
		555	didExecuteProgram(debuggerCallFrame, sourceID, lineNumber, 0);
		556	}
		557
		558	void ScriptDebugServer::didExecuteProgram(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber)
		559	{
450	if (m_paused)	560	if (m_paused)
451	return;	561	return;
452		562
453	updateCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber);	563	updateCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber, columnNumber);
454		564
455	// Treat stepping over the end of a program like stepping out.	565	// Treat stepping over the end of a program like stepping out.
456	if (m_currentCallFrame == m_pauseOnCallFrame)	566	if (m_currentCallFrame == m_pauseOnCallFrame)
Lines 460-470 void ScriptDebugServer::didExecuteProgram(const DebuggerCallFrame& debuggerCallF a/Source/WebCore/bindings/js/ScriptDebugServer.cpp_sec7
460		570
461	void ScriptDebugServer::didReachBreakpoint(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)	571	void ScriptDebugServer::didReachBreakpoint(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber)
462	{	572	{
		573	didReachBreakpoint(debuggerCallFrame, sourceID, lineNumber, 0);
		574	}
		575
		576	void ScriptDebugServer::didReachBreakpoint(const DebuggerCallFrame& debuggerCallFrame, intptr_t sourceID, int lineNumber, int columnNumber)
		577	{
463	if (m_paused)	578	if (m_paused)
464	return;	579	return;
465		580
466	m_pauseOnNextStatement = true;	581	m_pauseOnNextStatement = true;
467	updateCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber);	582	updateCallFrameAndPauseIfNeeded(debuggerCallFrame, sourceID, lineNumber, columnNumber);
468	}	583	}
469		584
470	void ScriptDebugServer::recompileAllJSFunctionsSoon()	585	void ScriptDebugServer::recompileAllJSFunctionsSoon()

Lines 123-130 protected: a/Source/WebCore/bindings/js/ScriptDebugServer.h_sec1
- a/Source/WebCore/bindings/js/ScriptDebugServer.h -3 / +19 lines
123	void dispatchDidParseSource(const ListenerSet& listeners, JSC::SourceProvider*, bool isContentScript);	123	void dispatchDidParseSource(const ListenerSet& listeners, JSC::SourceProvider*, bool isContentScript);
124	void dispatchFailedToParseSource(const ListenerSet& listeners, JSC::SourceProvider*, int errorLine, const String& errorMessage);	124	void dispatchFailedToParseSource(const ListenerSet& listeners, JSC::SourceProvider*, int errorLine, const String& errorMessage);
125		125
126	void createCallFrameAndPauseIfNeeded(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineNumber);	126	void createCallFrameAndPauseIfNeeded(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineNumber, int columnNumber);
127	void updateCallFrameAndPauseIfNeeded(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineNumber);	127	void updateCallFrameAndPauseIfNeeded(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineNumber, int columnNumber);
128	void pauseIfNeeded(JSC::JSGlobalObject* dynamicGlobalObject);	128	void pauseIfNeeded(JSC::JSGlobalObject* dynamicGlobalObject);
129		129
130	virtual void detach(JSC::JSGlobalObject*);	130	virtual void detach(JSC::JSGlobalObject*);
Lines 138-144 protected: a/Source/WebCore/bindings/js/ScriptDebugServer.h_sec2
138	virtual void didExecuteProgram(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineno);	138	virtual void didExecuteProgram(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineno);
139	virtual void didReachBreakpoint(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineno);	139	virtual void didReachBreakpoint(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineno);
140		140
141	typedef HashMap<long, ScriptBreakpoint> LineToBreakpointMap;	141	virtual void callEvent(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineNumber, int columnNumber);
		142	virtual void atStatement(const JSC::DebuggerCallFrame&, intptr_t sourceID, int firstLine, int columnNumber);
		143	virtual void returnEvent(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineNumber, int columnNumber);
		144	virtual void exception(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineNumber, int columnNumber, bool hasHandler);
		145	virtual void willExecuteProgram(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineno, int columnNumber);
		146	virtual void didExecuteProgram(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineno, int columnNumber);
		147	virtual void didReachBreakpoint(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineno, int columnNumber);
		148
		149
		150	void updateCurrentStatementPosition(intptr_t, int);
		151
		152	typedef Vector<ScriptBreakpoint> BreakpointsInLine;
		153	typedef HashMap<long, BreakpointsInLine> LineToBreakpointMap;
142	typedef HashMap<intptr_t, LineToBreakpointMap> SourceIdToBreakpointsMap;	154	typedef HashMap<intptr_t, LineToBreakpointMap> SourceIdToBreakpointsMap;
143		155
144	bool m_callingListeners;	156	bool m_callingListeners;
Lines 151-156 protected: a/Source/WebCore/bindings/js/ScriptDebugServer.h_sec3
151	RefPtr<JavaScriptCallFrame> m_currentCallFrame;	163	RefPtr<JavaScriptCallFrame> m_currentCallFrame;
152	SourceIdToBreakpointsMap m_sourceIdToBreakpoints;	164	SourceIdToBreakpointsMap m_sourceIdToBreakpoints;
153	Timer<ScriptDebugServer> m_recompileTimer;	165	Timer<ScriptDebugServer> m_recompileTimer;
		166
		167	Vector<String> m_currentSourceCode;
		168	intptr_t m_currentSourceID;
		169	ScriptBreakpoint m_currentStatementPosition;
154	};	170	};
155		171
156	} // namespace WebCore	172	} // namespace WebCore