1 files changed, 75 insertions, 570 deletions

diff --git a/src/qml/jsruntime/qv4debugging.cpp b/src/qml/jsruntime/qv4debugging.cpp
index 36e7a3558c..7706a40da6 100644
--- a/src/qml/jsruntime/qv4debugging.cpp
+++ b/src/qml/jsruntime/qv4debugging.cpp
@@ -38,69 +38,72 @@
 #include "qv4instr_moth_p.h"
 #include "qv4runtime_p.h"
 #include "qv4script_p.h"
-#include "qv4objectiterator_p.h"
 #include "qv4identifier_p.h"
-#include <iostream>
+#include "qv4string_p.h"
+#include "qv4objectiterator_p.h"
 
+#include <iostream>
 #include <algorithm>
 
+#include <QtCore/QJsonArray>
+#include <QtCore/QJsonDocument>
+#include <QtCore/QJsonValue>
+
+QT_BEGIN_NAMESPACE
+
 using namespace QV4;
 using namespace QV4::Debugging;
 
-namespace {
-class JavaScriptJob: public Debugger::Job
-{
-    QV4::ExecutionEngine *engine;
-    int frameNr;
-    const QString &script;
+V4Debugger::JavaScriptJob::JavaScriptJob(QV4::ExecutionEngine *engine, int frameNr,
+                                       const QString &script)
+    : engine(engine)
+    , frameNr(frameNr)
+    , script(script)
+    , resultIsException(false)
+{}
 
-public:
-    JavaScriptJob(QV4::ExecutionEngine *engine, int frameNr, const QString &script)
-        : engine(engine)
-        , frameNr(frameNr)
-        , script(script)
-    {}
-
-    void run()
-    {
-        Scope scope(engine);
+void V4Debugger::JavaScriptJob::run()
+{
+    Scope scope(engine);
 
-        ExecutionContextSaver saver(scope, engine->currentContext());
+    ExecutionContextSaver saver(scope);
 
-        if (frameNr > 0) {
-            Value *savedContexts = scope.alloc(frameNr);
-            for (int i = 0; i < frameNr; ++i) {
-                savedContexts[i] = engine->currentContext();
-                engine->popContext();
-            }
+    ExecutionContext *ctx = engine->currentContext;
+    if (frameNr > 0) {
+        for (int i = 0; i < frameNr; ++i) {
+            ctx = engine->parentContext(ctx);
         }
+        engine->pushContext(ctx);
+    }
 
-        ScopedContext ctx(scope, engine->currentContext());
-        QV4::Script script(ctx, this->script);
-        script.strictMode = ctx->d()->strictMode;
-        // In order for property lookups in QML to work, we need to disable fast v4 lookups. That
-        // is a side-effect of inheritContext.
-        script.inheritContext = true;
-        script.parse();
-        QV4::ScopedValue result(scope);
-        if (!scope.engine->hasException)
-            result = script.run();
-        if (scope.engine->hasException)
-            result = scope.engine->catchException();
-        handleResult(result);
+    QV4::Script script(ctx, this->script);
+    script.strictMode = ctx->d()->strictMode;
+    // In order for property lookups in QML to work, we need to disable fast v4 lookups. That
+    // is a side-effect of inheritContext.
+    script.inheritContext = true;
+    script.parse();
+    QV4::ScopedValue result(scope);
+    if (!scope.engine->hasException)
+        result = script.run();
+    if (scope.engine->hasException) {
+        result = scope.engine->catchException();
+        resultIsException = true;
     }
+    handleResult(result);
+}
 
-protected:
-    virtual void handleResult(QV4::ScopedValue &result) = 0;
-};
+bool V4Debugger::JavaScriptJob::hasExeption() const
+{
+    return resultIsException;
+}
 
-class EvalJob: public JavaScriptJob
+class EvalJob: public V4Debugger::JavaScriptJob
 {
     bool result;
 
 public:
     EvalJob(QV4::ExecutionEngine *engine, const QString &script)
-        : JavaScriptJob(engine, /*frameNr*/-1, script)
+        : V4Debugger::JavaScriptJob(engine, /*frameNr*/-1, script)
         , result(false)
     {}
 
@@ -115,58 +118,8 @@ public:
     }
 };
 
-class ExpressionEvalJob: public JavaScriptJob
-{
-    Debugger::Collector *collector;
-
-public:
-    ExpressionEvalJob(ExecutionEngine *engine, int frameNr, const QString &expression, Debugger::Collector *collector)
-        : JavaScriptJob(engine, frameNr, expression)
-        , collector(collector)
-    {
-    }
-
-    virtual void handleResult(QV4::ScopedValue &result)
-    {
-        collector->collect(QStringLiteral("body"), result);
-    }
-};
-
-class GatherSourcesJob: public Debugger::Job
-{
-    QV4::ExecutionEngine *engine;
-    const int seq;
-
-public:
-    GatherSourcesJob(QV4::ExecutionEngine *engine, int seq)
-        : engine(engine)
-        , seq(seq)
-    {}
-
-    ~GatherSourcesJob() {}
-
-    void run()
-    {
-        QStringList sources;
-
-        foreach (QV4::CompiledData::CompilationUnit *unit, engine->compilationUnits) {
-            QString fileName = unit->fileName();
-            if (!fileName.isEmpty())
-                sources.append(fileName);
-        }
-
-        Debugger *debugger = engine->debugger;
-        QMetaObject::invokeMethod(debugger->agent(), "sourcesCollected", Qt::QueuedConnection,
-                                  Q_ARG(QV4::Debugging::Debugger*, debugger),
-                                  Q_ARG(QStringList, sources),
-                                  Q_ARG(int, seq));
-    }
-};
-}
-
-Debugger::Debugger(QV4::ExecutionEngine *engine)
+V4Debugger::V4Debugger(QV4::ExecutionEngine *engine)
     : m_engine(engine)
-    , m_agent(0)
     , m_state(Running)
     , m_stepping(NotStepping)
     , m_pauseRequested(false)
@@ -176,46 +129,11 @@ Debugger::Debugger(QV4::ExecutionEngine *engine)
     , m_gatherSources(0)
     , m_runningJob(0)
 {
-    qMetaTypeId<Debugger*>();
+    qMetaTypeId<V4Debugger*>();
     qMetaTypeId<PauseReason>();
 }
 
-Debugger::~Debugger()
-{
-    detachFromAgent();
-}
-
-void Debugger::attachToAgent(DebuggerAgent *agent)
-{
-    Q_ASSERT(!m_agent);
-    m_agent = agent;
-}
-
-void Debugger::detachFromAgent()
-{
-    DebuggerAgent *agent = 0;
-    {
-        QMutexLocker locker(&m_lock);
-        agent = m_agent;
-        m_agent = 0;
-    }
-    if (agent)
-        agent->removeDebugger(this);
-}
-
-void Debugger::gatherSources(int requestSequenceNr)
-{
-    QMutexLocker locker(&m_lock);
-
-    m_gatherSources = new GatherSourcesJob(m_engine, requestSequenceNr);
-    if (m_state == Paused) {
-        runInEngine_havingLock(m_gatherSources);
-        delete m_gatherSources;
-        m_gatherSources = 0;
-    }
-}
-
-void Debugger::pause()
+void V4Debugger::pause()
 {
     QMutexLocker locker(&m_lock);
     if (m_state == Paused)
@@ -223,7 +141,7 @@ void Debugger::pause()
     m_pauseRequested = true;
 }
 
-void Debugger::resume(Speed speed)
+void V4Debugger::resume(Speed speed)
 {
     QMutexLocker locker(&m_lock);
     if (m_state != Paused)
@@ -232,292 +150,47 @@ void Debugger::resume(Speed speed)
     if (!m_returnedValue.isUndefined())
         m_returnedValue.set(m_engine, Encode::undefined());
 
-    m_currentContext.set(m_engine, m_engine->currentContext());
+    m_currentContext.set(m_engine, *m_engine->currentContext);
     m_stepping = speed;
     m_runningCondition.wakeAll();
 }
 
-void Debugger::addBreakPoint(const QString &fileName, int lineNumber, const QString &condition)
+void V4Debugger::addBreakPoint(const QString &fileName, int lineNumber, const QString &condition)
 {
     QMutexLocker locker(&m_lock);
     m_breakPoints.insert(DebuggerBreakPoint(fileName.mid(fileName.lastIndexOf('/') + 1), lineNumber), condition);
     m_haveBreakPoints = true;
 }
 
-void Debugger::removeBreakPoint(const QString &fileName, int lineNumber)
+void V4Debugger::removeBreakPoint(const QString &fileName, int lineNumber)
 {
     QMutexLocker locker(&m_lock);
     m_breakPoints.remove(DebuggerBreakPoint(fileName.mid(fileName.lastIndexOf('/') + 1), lineNumber));
     m_haveBreakPoints = !m_breakPoints.isEmpty();
 }
 
-void Debugger::setBreakOnThrow(bool onoff)
+void V4Debugger::setBreakOnThrow(bool onoff)
 {
     QMutexLocker locker(&m_lock);
 
     m_breakOnThrow = onoff;
 }
 
-Debugger::ExecutionState Debugger::currentExecutionState() const
+V4Debugger::ExecutionState V4Debugger::currentExecutionState() const
 {
     ExecutionState state;
     state.fileName = getFunction()->sourceFile();
-    state.lineNumber = engine()->currentContext()->lineNumber;
+    state.lineNumber = engine()->current->lineNumber;
 
     return state;
 }
 
-QVector<StackFrame> Debugger::stackTrace(int frameLimit) const
+QVector<StackFrame> V4Debugger::stackTrace(int frameLimit) const
 {
     return m_engine->stackTrace(frameLimit);
 }
 
-static inline Heap::CallContext *findContext(Heap::ExecutionContext *ctxt, int frame)
-{
-    if (!ctxt)
-        return 0;
-
-    Scope scope(ctxt->engine);
-    ScopedContext ctx(scope, ctxt);
-    while (ctx) {
-        CallContext *cCtxt = ctx->asCallContext();
-        if (cCtxt && cCtxt->d()->function) {
-            if (frame < 1)
-                return cCtxt->d();
-            --frame;
-        }
-        ctx = ctx->d()->parent;
-    }
-
-    return 0;
-}
-
-static inline Heap::CallContext *findScope(Heap::ExecutionContext *ctxt, int scope)
-{
-    if (!ctxt)
-        return 0;
-
-    Scope s(ctxt->engine);
-    ScopedContext ctx(s, ctxt);
-    for (; scope > 0 && ctx; --scope)
-        ctx = ctx->d()->outer;
-
-    return (ctx && ctx->d()) ? ctx->asCallContext()->d() : 0;
-}
-
-void Debugger::collectArgumentsInContext(Collector *collector, int frameNr, int scopeNr)
-{
-    if (state() != Paused)
-        return;
-
-    class ArgumentCollectJob: public Job
-    {
-        QV4::ExecutionEngine *engine;
-        Collector *collector;
-        int frameNr;
-        int scopeNr;
-
-    public:
-        ArgumentCollectJob(QV4::ExecutionEngine *engine, Collector *collector, int frameNr, int scopeNr)
-            : engine(engine)
-            , collector(collector)
-            , frameNr(frameNr)
-            , scopeNr(scopeNr)
-        {}
-
-        ~ArgumentCollectJob() {}
-
-        void run()
-        {
-            if (frameNr < 0)
-                return;
-
-            Scope scope(engine);
-            Scoped<CallContext> ctxt(scope, findScope(findContext(engine->currentContext(), frameNr), scopeNr));
-            if (!ctxt)
-                return;
-
-            ScopedValue v(scope);
-            int nFormals = ctxt->formalCount();
-            for (unsigned i = 0, ei = nFormals; i != ei; ++i) {
-                QString qName;
-                if (Identifier *name = ctxt->formals()[nFormals - i - 1])
-                    qName = name->string;
-                v = ctxt->argument(i);
-                collector->collect(qName, v);
-            }
-        }
-    };
-
-    ArgumentCollectJob job(m_engine, collector, frameNr, scopeNr);
-    runInEngine(&job);
-}
-
-/// Same as \c retrieveArgumentsFromContext, but now for locals.
-void Debugger::collectLocalsInContext(Collector *collector, int frameNr, int scopeNr)
-{
-    if (state() != Paused)
-        return;
-
-    class LocalCollectJob: public Job
-    {
-        QV4::ExecutionEngine *engine;
-        Collector *collector;
-        int frameNr;
-        int scopeNr;
-
-    public:
-        LocalCollectJob(QV4::ExecutionEngine *engine, Collector *collector, int frameNr, int scopeNr)
-            : engine(engine)
-            , collector(collector)
-            , frameNr(frameNr)
-            , scopeNr(scopeNr)
-        {}
-
-        void run()
-        {
-            if (frameNr < 0)
-                return;
-
-            Scope scope(engine);
-            Scoped<CallContext> ctxt(scope, findScope(findContext(engine->currentContext(), frameNr), scopeNr));
-            if (!ctxt)
-                return;
-
-            ScopedValue v(scope);
-            for (unsigned i = 0, ei = ctxt->variableCount(); i != ei; ++i) {
-                QString qName;
-                if (Identifier *name = ctxt->variables()[i])
-                    qName = name->string;
-                v = ctxt->d()->locals[i];
-                collector->collect(qName, v);
-            }
-        }
-    };
-
-    LocalCollectJob job(m_engine, collector, frameNr, scopeNr);
-    runInEngine(&job);
-}
-
-bool Debugger::collectThisInContext(Debugger::Collector *collector, int frame)
-{
-    if (state() != Paused)
-        return false;
-
-    class ThisCollectJob: public Job
-    {
-        QV4::ExecutionEngine *engine;
-        Collector *collector;
-        int frameNr;
-        bool *foundThis;
-
-    public:
-        ThisCollectJob(QV4::ExecutionEngine *engine, Collector *collector, int frameNr, bool *foundThis)
-            : engine(engine)
-            , collector(collector)
-            , frameNr(frameNr)
-            , foundThis(foundThis)
-        {}
-
-        void run()
-        {
-            *foundThis = myRun();
-        }
-
-        bool myRun()
-        {
-            Scope scope(engine);
-            ScopedContext ctxt(scope, findContext(engine->currentContext(), frameNr));
-            while (ctxt) {
-                if (CallContext *cCtxt = ctxt->asCallContext())
-                    if (cCtxt->d()->activation)
-                        break;
-                ctxt = ctxt->d()->outer;
-            }
-
-            if (!ctxt)
-                return false;
-
-            ScopedObject o(scope, ctxt->asCallContext()->d()->activation);
-            collector->collect(o);
-            return true;
-        }
-    };
-
-    bool foundThis = false;
-    ThisCollectJob job(m_engine, collector, frame, &foundThis);
-    runInEngine(&job);
-    return foundThis;
-}
-
-void Debugger::collectThrownValue(Collector *collector)
-{
-    if (state() != Paused || !m_engine->hasException)
-        return;
-
-    class ThisCollectJob: public Job
-    {
-        QV4::ExecutionEngine *engine;
-        Collector *collector;
-
-    public:
-        ThisCollectJob(QV4::ExecutionEngine *engine, Collector *collector)
-            : engine(engine)
-            , collector(collector)
-        {}
-
-        void run()
-        {
-            Scope scope(engine);
-            ScopedValue v(scope, engine->exceptionValue);
-            collector->collect(QStringLiteral("exception"), v);
-        }
-    };
-
-    ThisCollectJob job(m_engine, collector);
-    runInEngine(&job);
-}
-
-void Debugger::collectReturnedValue(Collector *collector) const
-{
-    if (state() != Paused)
-        return;
-
-    Scope scope(m_engine);
-    ScopedObject o(scope, m_returnedValue.valueRef());
-    collector->collect(o);
-}
-
-QVector<Heap::ExecutionContext::ContextType> Debugger::getScopeTypes(int frame) const
-{
-    QVector<Heap::ExecutionContext::ContextType> types;
-
-    if (state() != Paused)
-        return types;
-
-    Scope scope(m_engine);
-    Scoped<CallContext> sctxt(scope, findContext(m_engine->currentContext(), frame));
-    if (!sctxt || sctxt->d()->type < Heap::ExecutionContext::Type_SimpleCallContext)
-        return types;
-
-    ScopedContext it(scope, sctxt->d());
-    for (; it; it = it->d()->outer)
-        types.append(it->d()->type);
-
-    return types;
-}
-
-
-void Debugger::evaluateExpression(int frameNr, const QString &expression, Debugger::Collector *resultsCollector)
-{
-    Q_ASSERT(state() == Paused);
-
-    Q_ASSERT(m_runningJob == 0);
-    ExpressionEvalJob job(m_engine, frameNr, expression, resultsCollector);
-    runInEngine(&job);
-}
-
-void Debugger::maybeBreakAtInstruction()
+void V4Debugger::maybeBreakAtInstruction()
 {
     if (m_runningJob) // do not re-enter when we're doing a job for the debugger.
         return;
@@ -532,7 +205,7 @@ void Debugger::maybeBreakAtInstruction()
 
     switch (m_stepping) {
     case StepOver:
-        if (m_currentContext.asManaged()->d() != m_engine->currentContext())
+        if (m_currentContext.asManaged()->d() != m_engine->current)
             break;
         // fall through
     case StepIn:
@@ -548,25 +221,25 @@ void Debugger::maybeBreakAtInstruction()
         pauseAndWait(PauseRequest);
     } else if (m_haveBreakPoints) {
         if (Function *f = getFunction()) {
-            const int lineNumber = engine()->currentContext()->lineNumber;
+            const int lineNumber = engine()->current->lineNumber;
             if (reallyHitTheBreakPoint(f->sourceFile(), lineNumber))
                 pauseAndWait(BreakPoint);
         }
     }
 }
 
-void Debugger::enteringFunction()
+void V4Debugger::enteringFunction()
 {
     if (m_runningJob)
         return;
     QMutexLocker locker(&m_lock);
 
     if (m_stepping == StepIn) {
-        m_currentContext.set(m_engine, m_engine->currentContext());
+        m_currentContext.set(m_engine, *m_engine->currentContext);
     }
 }
 
-void Debugger::leavingFunction(const ReturnedValue &retVal)
+void V4Debugger::leavingFunction(const ReturnedValue &retVal)
 {
     if (m_runningJob)
         return;
@@ -574,14 +247,14 @@ void Debugger::leavingFunction(const ReturnedValue &retVal)
 
     QMutexLocker locker(&m_lock);
 
-    if (m_stepping != NotStepping && m_currentContext.asManaged()->d() == m_engine->currentContext()) {
-        m_currentContext.set(m_engine, m_engine->currentContext()->parent);
+    if (m_stepping != NotStepping && m_currentContext.asManaged()->d() == m_engine->current) {
+        m_currentContext.set(m_engine, *m_engine->parentContext(m_engine->currentContext));
         m_stepping = StepOver;
         m_returnedValue.set(m_engine, retVal);
     }
 }
 
-void Debugger::aboutToThrow()
+void V4Debugger::aboutToThrow()
 {
     if (!m_breakOnThrow)
         return;
@@ -593,10 +266,10 @@ void Debugger::aboutToThrow()
     pauseAndWait(Throwing);
 }
 
-Function *Debugger::getFunction() const
+Function *V4Debugger::getFunction() const
 {
     Scope scope(m_engine);
-    ScopedContext context(scope, m_engine->currentContext());
+    ExecutionContext *context = m_engine->currentContext;
     ScopedFunctionObject function(scope, context->getFunctionObject());
     if (function)
         return function->function();
@@ -604,15 +277,13 @@ Function *Debugger::getFunction() const
         return context->d()->engine->globalCode;
 }
 
-void Debugger::pauseAndWait(PauseReason reason)
+void V4Debugger::pauseAndWait(PauseReason reason)
 {
     if (m_runningJob)
         return;
 
     m_state = Paused;
-    QMetaObject::invokeMethod(m_agent, "debuggerPaused", Qt::QueuedConnection,
-                              Q_ARG(QV4::Debugging::Debugger*, this),
-                              Q_ARG(QV4::Debugging::PauseReason, reason));
+    emit debuggerPaused(this, reason);
 
     while (true) {
         m_runningCondition.wait(&m_lock);
@@ -627,7 +298,7 @@ void Debugger::pauseAndWait(PauseReason reason)
     m_state = Running;
 }
 
-bool Debugger::reallyHitTheBreakPoint(const QString &filename, int linenr)
+bool V4Debugger::reallyHitTheBreakPoint(const QString &filename, int linenr)
 {
     BreakPoints::iterator it = m_breakPoints.find(DebuggerBreakPoint(filename.mid(filename.lastIndexOf('/') + 1), linenr));
     if (it == m_breakPoints.end())
@@ -645,13 +316,13 @@ bool Debugger::reallyHitTheBreakPoint(const QString &filename, int linenr)
     return evilJob.resultAsBoolean();
 }
 
-void Debugger::runInEngine(Debugger::Job *job)
+void V4Debugger::runInEngine(V4Debugger::Job *job)
 {
     QMutexLocker locker(&m_lock);
     runInEngine_havingLock(job);
 }
 
-void Debugger::runInEngine_havingLock(Debugger::Job *job)
+void V4Debugger::runInEngine_havingLock(V4Debugger::Job *job)
 {
     Q_ASSERT(job);
     Q_ASSERT(m_runningJob == 0);
@@ -662,174 +333,8 @@ void Debugger::runInEngine_havingLock(Debugger::Job *job)
     m_runningJob = 0;
 }
 
-void DebuggerAgent::addDebugger(Debugger *debugger)
-{
-    Q_ASSERT(!m_debuggers.contains(debugger));
-    m_debuggers << debugger;
-    debugger->attachToAgent(this);
-
-    debugger->setBreakOnThrow(m_breakOnThrow);
-
-    foreach (const BreakPoint &breakPoint, m_breakPoints.values())
-        if (breakPoint.enabled)
-            debugger->addBreakPoint(breakPoint.fileName, breakPoint.lineNr, breakPoint.condition);
-}
-
-void DebuggerAgent::removeDebugger(Debugger *debugger)
-{
-    m_debuggers.removeAll(debugger);
-    debugger->detachFromAgent();
-}
-
-void DebuggerAgent::pause(Debugger *debugger) const
-{
-    debugger->pause();
-}
-
-void DebuggerAgent::pauseAll() const
+V4Debugger::Job::~Job()
 {
-    foreach (Debugger *debugger, m_debuggers)
-        pause(debugger);
 }
 
-void DebuggerAgent::resumeAll() const
-{
-    foreach (Debugger *debugger, m_debuggers)
-        if (debugger->state() == Debugger::Paused)
-            debugger->resume(Debugger::FullThrottle);
-}
-
-int DebuggerAgent::addBreakPoint(const QString &fileName, int lineNumber, bool enabled, const QString &condition)
-{
-    if (enabled)
-        foreach (Debugger *debugger, m_debuggers)
-            debugger->addBreakPoint(fileName, lineNumber, condition);
-
-    int id = m_breakPoints.size();
-    m_breakPoints.insert(id, BreakPoint(fileName, lineNumber, enabled, condition));
-    return id;
-}
-
-void DebuggerAgent::removeBreakPoint(int id)
-{
-    BreakPoint breakPoint = m_breakPoints.value(id);
-    if (!breakPoint.isValid())
-        return;
-
-    m_breakPoints.remove(id);
-
-    if (breakPoint.enabled)
-        foreach (Debugger *debugger, m_debuggers)
-            debugger->removeBreakPoint(breakPoint.fileName, breakPoint.lineNr);
-}
-
-void DebuggerAgent::removeAllBreakPoints()
-{
-    QList<int> ids = m_breakPoints.keys();
-    foreach (int id, ids)
-        removeBreakPoint(id);
-}
-
-void DebuggerAgent::enableBreakPoint(int id, bool onoff)
-{
-    BreakPoint &breakPoint = m_breakPoints[id];
-    if (!breakPoint.isValid() || breakPoint.enabled == onoff)
-        return;
-    breakPoint.enabled = onoff;
-
-    foreach (Debugger *debugger, m_debuggers) {
-        if (onoff)
-            debugger->addBreakPoint(breakPoint.fileName, breakPoint.lineNr, breakPoint.condition);
-        else
-            debugger->removeBreakPoint(breakPoint.fileName, breakPoint.lineNr);
-    }
-}
-
-QList<int> DebuggerAgent::breakPointIds(const QString &fileName, int lineNumber) const
-{
-    QList<int> ids;
-
-    for (QHash<int, BreakPoint>::const_iterator i = m_breakPoints.begin(), ei = m_breakPoints.end(); i != ei; ++i)
-        if (i->lineNr == lineNumber && fileName.endsWith(i->fileName))
-            ids.push_back(i.key());
-
-    return ids;
-}
-
-void DebuggerAgent::setBreakOnThrow(bool onoff)
-{
-    if (onoff != m_breakOnThrow) {
-        m_breakOnThrow = onoff;
-        foreach (Debugger *debugger, m_debuggers)
-            debugger->setBreakOnThrow(onoff);
-    }
-}
-
-DebuggerAgent::~DebuggerAgent()
-{
-    foreach (Debugger *debugger, m_debuggers)
-        debugger->detachFromAgent();
-
-    Q_ASSERT(m_debuggers.isEmpty());
-}
-
-Debugger::Collector::~Collector()
-{
-}
-
-void Debugger::Collector::collect(const QString &name, const ScopedValue &value)
-{
-    switch (value->type()) {
-    case Value::Empty_Type:
-        Q_ASSERT(!"empty Value encountered");
-        break;
-    case Value::Undefined_Type:
-        addUndefined(name);
-        break;
-    case Value::Null_Type:
-        addNull(name);
-        break;
-    case Value::Boolean_Type:
-        addBoolean(name, value->booleanValue());
-        break;
-    case Value::Managed_Type:
-        if (String *s = value->asString())
-            addString(name, s->toQString());
-        else
-            addObject(name, value);
-        break;
-    case Value::Integer_Type:
-        addInteger(name, value->int_32);
-        break;
-    default: // double
-        addDouble(name, value->doubleValue());
-        break;
-    }
-}
-
-void Debugger::Collector::collect(Object *object)
-{
-    bool property = true;
-    qSwap(property, m_isProperty);
-
-    Scope scope(m_engine);
-    ObjectIterator it(scope, object, ObjectIterator::EnumerableOnly);
-    ScopedValue name(scope);
-    ScopedValue value(scope);
-    while (true) {
-        Value v;
-        name = it.nextPropertyNameAsString(&v);
-        if (name->isNull())
-            break;
-        QString key = name->toQStringNoThrow();
-        value = v;
-        collect(key, value);
-    }
-
-    qSwap(property, m_isProperty);
-}
-
-
-Debugger::Job::~Job()
-{
-}
+QT_END_NAMESPACE