Changeset 47304 in webkit for trunk/JavaScriptCore/parser/Parser.h

Timestamp:

Aug 14, 2009, 6:14:00 PM (16 years ago)

Author:

[email protected]

Message:

Remove AST nodes from use within the Runtime (outside of parsing), stage 1
​https://bugs.webkit.org/show_bug.cgi?id=28330

Reviewed by Oliver Hunt.

Remove the EvalNode and ProgramNode from use in the runtime. They still exist
after this patch, but are hidden behind EvalExecutable and FunctionExecutable,
and are also still reachable behind CodeBlock::m_ownerNode.

The next step will be to beat back FunctionBodyNode in the same fashion.
Then remove the usage via CodeBlock, then only construct these nodes only on
demand during bytecode generation.

• JavaScriptCore.xcodeproj/project.pbxproj:
• bytecode/CodeBlock.h:

(JSC::GlobalCodeBlock::GlobalCodeBlock):
(JSC::GlobalCodeBlock::~GlobalCodeBlock):
(JSC::ProgramCodeBlock::ProgramCodeBlock):
(JSC::EvalCodeBlock::EvalCodeBlock):
(JSC::FunctionCodeBlock::FunctionCodeBlock):
(JSC::NativeCodeBlock::NativeCodeBlock):

• bytecode/EvalCodeCache.h:

(JSC::EvalCodeCache::get):

• debugger/Debugger.cpp:

(JSC::evaluateInGlobalCallFrame):

• debugger/DebuggerCallFrame.cpp:

(JSC::DebuggerCallFrame::evaluate):

• interpreter/Interpreter.cpp:

(JSC::Interpreter::callEval):
(JSC::Interpreter::execute):

• interpreter/Interpreter.h:
• parser/Nodes.cpp:

(JSC::FunctionBodyNode::createNativeThunk):
(JSC::FunctionBodyNode::generateBytecode):
(JSC::FunctionBodyNode::bytecodeForExceptionInfoReparse):

• parser/Parser.h:

(JSC::Parser::parse):
(JSC::Parser::reparse):
(JSC::Parser::parseFunctionFromGlobalCode):
(JSC::::parse):

• runtime/Completion.cpp:

(JSC::checkSyntax):
(JSC::evaluate):

• runtime/Error.cpp:

(JSC::throwError):

• runtime/Error.h:
• runtime/Executable.h: Added.

(JSC::TemplateExecutable::TemplateExecutable):
(JSC::TemplateExecutable::markAggregate):
(JSC::TemplateExecutable::sourceURL):
(JSC::TemplateExecutable::lineNo):
(JSC::TemplateExecutable::bytecode):
(JSC::TemplateExecutable::jitCode):
(JSC::EvalExecutable::EvalExecutable):
(JSC::ProgramExecutable::ProgramExecutable):

• runtime/FunctionConstructor.cpp:

(JSC::constructFunction):

• runtime/FunctionConstructor.h:
• runtime/JSGlobalData.cpp:

(JSC::JSGlobalData::numericCompareFunction):

• runtime/JSGlobalObject.cpp:

(JSC::JSGlobalObject::~JSGlobalObject):
(JSC::JSGlobalObject::markChildren):

• runtime/JSGlobalObject.h:

(JSC::JSGlobalObject::codeBlocks):

• runtime/JSGlobalObjectFunctions.cpp:

(JSC::globalFuncEval):

File:

• trunk/JavaScriptCore/parser/Parser.h (modified) (5 diffs)

trunk/JavaScriptCore/parser/Parser.h

@@ -25 +25 @@
 
 #include "Debugger.h"
+#include "Executable.h"
 #include "Nodes.h"
 #include "SourceProvider.h"
@@ -42 +43 @@
     class Parser : public Noncopyable {
     public:
-        template <class ParsedNode> PassRefPtr<ParsedNode> parse(ExecState*, Debugger*, const SourceCode&, int* errLine = 0, UString* errMsg = 0);
-        template <class ParsedNode> PassRefPtr<ParsedNode> reparse(JSGlobalData*, ParsedNode*);
+        template <class ParsedNode>
+        PassRefPtr<ParsedNode> parse(ExecState*, Debugger*, const SourceCode&, int* errLine = 0, UString* errMsg = 0);
+        template <class ParsedNode>
+        PassRefPtr<ParsedNode> reparse(JSGlobalData*, ParsedNode*);
         void reparseInPlace(JSGlobalData*, FunctionBodyNode*);
+        PassRefPtr<FunctionBodyNode> parseFunctionFromGlobalCode(ExecState*, Debugger*, const SourceCode&, int* errLine = 0, UString* errMsg = 0);
 
         void didFinishParsing(SourceElements*, ParserArenaData<DeclarationStacks::VarStack>*, 
@@ -64 +68 @@
     };
 
-    template <class ParsedNode> PassRefPtr<ParsedNode> Parser::parse(ExecState* exec, Debugger* debugger, const SourceCode& source, int* errLine, UString* errMsg)
+    template <class ParsedNode>
+    PassRefPtr<ParsedNode> Parser::parse(ExecState* exec, Debugger* debugger, const SourceCode& source, int* errLine, UString* errMsg)
     {
         m_source = &source;
@@ -91 +96 @@
     }
 
-    template <class ParsedNode> PassRefPtr<ParsedNode> Parser::reparse(JSGlobalData* globalData, ParsedNode* oldParsedNode)
+    template <class ParsedNode>
+    PassRefPtr<ParsedNode> Parser::reparse(JSGlobalData* globalData, ParsedNode* oldParsedNode)
     {
         m_source = &oldParsedNode->source();
@@ -116 +122 @@
     }
 
+    inline PassRefPtr<FunctionBodyNode> Parser::parseFunctionFromGlobalCode(ExecState* exec, Debugger* debugger, const SourceCode& source, int* errLine, UString* errMsg)
+    {
+        RefPtr<ProgramNode> program = parse<ProgramNode>(exec, debugger, source, errLine, errMsg);
+
+        if (!program)
+            return 0;
+
+        StatementVector& children = program->children();
+        if (children.size() != 1)
+            return 0;
+
+        StatementNode* exprStatement = children[0];
+        ASSERT(exprStatement);
+        ASSERT(exprStatement->isExprStatement());
+        if (!exprStatement || !exprStatement->isExprStatement())
+            return 0;
+
+        ExpressionNode* funcExpr = static_cast<ExprStatementNode*>(exprStatement)->expr();
+        ASSERT(funcExpr);
+        ASSERT(funcExpr->isFuncExprNode());
+        if (!funcExpr || !funcExpr->isFuncExprNode())
+            return 0;
+
+        RefPtr<FunctionBodyNode> body = static_cast<FuncExprNode*>(funcExpr)->body();
+        ASSERT(body);
+        return body.release();
+    }
+
+    template<class ASTNodeType, class CodeBlockType>
+    inline JSObject* TemplateExecutable<ASTNodeType, CodeBlockType>::parse(ExecState* exec, bool allowDebug)
+    {
+        int errLine;
+        UString errMsg;
+        m_node = exec->globalData().parser->parse<ASTNodeType>(exec, allowDebug ? exec->dynamicGlobalObject()->debugger() : 0, m_source, &errLine, &errMsg);
+
+        if (!m_node)
+            return Error::create(exec, SyntaxError, errMsg, errLine, m_source.provider()->asID(), m_source.provider()->url());
+        return 0;
+    }
+
 } // namespace JSC