JavaScriptCore-1218.0.1.tar.gz

[apple/javascriptcore.git] / debugger / Debugger.cpp

diff --git a/debugger/Debugger.cpp b/debugger/Debugger.cpp
index da1cb3dd5231999b1245fdb5ef76b8e5782c6b7a..0f0b31d283572b5d45d51eb10d8c3c61b9856cf5 100644 (file)
--- a/debugger/Debugger.cpp
+++ b/debugger/Debugger.cpp
@@ -22,16 +22,86 @@
 #include "config.h"
 #include "Debugger.h"
 
 #include "config.h"
 #include "Debugger.h"
 

-#include "JSGlobalObject.h"
+#include "Error.h"

 #include "Interpreter.h"
 #include "Interpreter.h"

+#include "JSFunction.h"
+#include "JSGlobalObject.h"
+#include "Operations.h"

 #include "Parser.h"
 #include "Parser.h"

+#include "Protect.h"

 
 

-namespace JSC {
+namespace {
+
+using namespace JSC;
+
+class Recompiler : public MarkedBlock::VoidFunctor {
+public:
+#if PLATFORM(IOS)
+    Recompiler(JSC::Debugger*);
+#else
+    Recompiler(Debugger*);
+#endif
+    ~Recompiler();
+    void operator()(JSCell*);
+
+private:
+    typedef HashSet<FunctionExecutable*> FunctionExecutableSet;
+    typedef HashMap<SourceProvider*, ExecState*> SourceProviderMap;
+    
+#if PLATFORM(IOS)
+    JSC::Debugger* m_debugger;
+#else
+    Debugger* m_debugger;
+#endif
+    FunctionExecutableSet m_functionExecutables;
+    SourceProviderMap m_sourceProviders;
+};

 
 

-Debugger::Debugger()
+#if PLATFORM(IOS)
+inline Recompiler::Recompiler(JSC::Debugger* debugger)
+#else
+inline Recompiler::Recompiler(Debugger* debugger)
+#endif
+    : m_debugger(debugger)

 {
 }
 
 {
 }
 

+inline Recompiler::~Recompiler()
+{
+    // Call sourceParsed() after reparsing all functions because it will execute
+    // JavaScript in the inspector.
+    SourceProviderMap::const_iterator end = m_sourceProviders.end();
+    for (SourceProviderMap::const_iterator iter = m_sourceProviders.begin(); iter != end; ++iter)
+        m_debugger->sourceParsed(iter->value, iter->key, -1, String());
+}
+
+inline void Recompiler::operator()(JSCell* cell)
+{
+    if (!cell->inherits(&JSFunction::s_info))
+        return;
+
+    JSFunction* function = jsCast<JSFunction*>(cell);
+    if (function->executable()->isHostFunction())
+        return;
+
+    FunctionExecutable* executable = function->jsExecutable();
+
+    // Check if the function is already in the set - if so,
+    // we've already retranslated it, nothing to do here.
+    if (!m_functionExecutables.add(executable).isNewEntry)
+        return;
+
+    ExecState* exec = function->scope()->globalObject()->JSGlobalObject::globalExec();
+    executable->clearCodeIfNotCompiling();
+    executable->clearUnlinkedCodeForRecompilationIfNotCompiling();
+    if (m_debugger == function->scope()->globalObject()->debugger())
+        m_sourceProviders.add(executable->source().provider(), exec);
+}
+
+} // namespace
+
+namespace JSC {
+

 Debugger::~Debugger()
 {
     HashSet<JSGlobalObject*>::iterator end = m_globalObjects.end();
 Debugger::~Debugger()
 {
     HashSet<JSGlobalObject*>::iterator end = m_globalObjects.end();


@@ -53,18 +123,37 @@ void Debugger::detach(JSGlobalObject* globalObject)
     globalObject->setDebugger(0);
 }
 
     globalObject->setDebugger(0);
 }
 

-JSValuePtr evaluateInGlobalCallFrame(const UString& script, JSValuePtr& exception, JSGlobalObject* globalObject)
+void Debugger::recompileAllJSFunctions(VM* vm)
+{
+    // If JavaScript is running, it's not safe to recompile, since we'll end
+    // up throwing away code that is live on the stack.
+    ASSERT(!vm->dynamicGlobalObject);
+    if (vm->dynamicGlobalObject)
+        return;
+
+    Recompiler recompiler(this);
+    vm->heap.objectSpace().forEachLiveCell(recompiler);
+}
+
+JSValue evaluateInGlobalCallFrame(const String& script, JSValue& exception, JSGlobalObject* globalObject)

 {
     CallFrame* globalCallFrame = globalObject->globalExec();
 {
     CallFrame* globalCallFrame = globalObject->globalExec();

+    VM& vm = globalObject->vm();

 
 

-    int errLine;
-    UString errMsg;
-    SourceCode source = makeSource(script);
-    RefPtr<EvalNode> evalNode = globalObject->globalData()->parser->parse<EvalNode>(globalCallFrame, globalObject->debugger(), source, &errLine, &errMsg);
-    if (!evalNode)
-        return Error::create(globalCallFrame, SyntaxError, errMsg, errLine, source.provider()->asID(), source.provider()->url());
+    EvalExecutable* eval = EvalExecutable::create(globalCallFrame, vm.codeCache(), makeSource(script), false);
+    if (!eval) {
+        exception = vm.exception;
+        vm.exception = JSValue();
+        return exception;
+    }

 
 

-    return globalObject->globalData()->interpreter->execute(evalNode.get(), globalCallFrame, globalObject, globalCallFrame->scopeChain(), &exception);
+    JSValue result = vm.interpreter->execute(eval, globalCallFrame, globalObject, globalCallFrame->scope());
+    if (vm.exception) {
+        exception = vm.exception;
+        vm.exception = JSValue();
+    }
+    ASSERT(result);
+    return result;

 }
 
 } // namespace JSC
 }
 
 } // namespace JSC