debugger: code cosmetics

src/plugins/debugger/debuggerconstants.h

@@ -219,7 +219,7 @@ enum DebuggerEngineType
     TcfEngineType     = 0x10,
     QmlEngineType     = 0x20,
     QmlCppEngineType  = 0x40,
-    LLDBEngineType  = 0x80,
+    LldbEngineType  = 0x80,
     AllEngineTypes = GdbEngineType
         | ScriptEngineType
         | CdbEngineType
@@ -227,7 +227,7 @@ enum DebuggerEngineType
         | TcfEngineType
         | QmlEngineType
         | QmlCppEngineType
-        | LLDBEngineType
+        | LldbEngineType
 };
 
 enum DebuggerLanguage

src/plugins/debugger/debuggerrunner.cpp

@@ -75,7 +75,7 @@ DebuggerEngine *createPdbEngine(const DebuggerStartParameters &);
 DebuggerEngine *createTcfEngine(const DebuggerStartParameters &);
 DebuggerEngine *createQmlEngine(const DebuggerStartParameters &);
 DebuggerEngine *createQmlCppEngine(const DebuggerStartParameters &);
-DebuggerEngine *createLLDBEngine(const DebuggerStartParameters &);
+DebuggerEngine *createLldbEngine(const DebuggerStartParameters &);
 
 extern QString msgNoBinaryForToolChain(int tc);
 
@@ -95,6 +95,8 @@ bool checkCdbConfiguration(int, QString *, QString *) { return false; }
 #endif
 
 } // namespace Internal
+
+
 namespace Cdb {
 DebuggerEngine *createCdbEngine(const DebuggerStartParameters &, QString *errorMessage);
 bool isCdbEngineEnabled(); // Check the configuration page
@@ -243,16 +245,28 @@ QWidget *DebuggerRunControlFactory::createConfigurationWidget
 
 ////////////////////////////////////////////////////////////////////////
 //
-// DebuggerRunControl
+// DebuggerRunControlPrivate
 //
 ////////////////////////////////////////////////////////////////////////
 
-struct DebuggerRunnerPrivate {
-    explicit DebuggerRunnerPrivate(RunConfiguration *runConfiguration,
-                                   unsigned enabledEngines);
-
+class DebuggerRunControlPrivate
+{
+public:
+    DebuggerRunControlPrivate(DebuggerRunControl *parent,
+        RunConfiguration *runConfiguration, unsigned enabledEngines);
     unsigned enabledEngines() const;
 
+    DebuggerEngineType engineForExecutable(unsigned enabledEngineTypes,
+        const QString &executable);
+    DebuggerEngineType engineForMode(unsigned enabledEngineTypes,
+        DebuggerStartMode mode);
+
+    void initGdbEngine(GdbEngine *engine);
+    GdbEngine *gdbEngine() const;
+    AbstractGdbAdapter *gdbAdapter() const;
+
+public:
+    DebuggerRunControl *q;
     DebuggerEngine *m_engine;
     const QWeakPointer<RunConfiguration> m_myRunConfiguration;
     bool m_running;
@@ -261,33 +275,150 @@ struct DebuggerRunnerPrivate {
     QString m_settingsIdHint;
 };
 
-unsigned DebuggerRunnerPrivate::enabledEngines() const
+unsigned DebuggerRunControlPrivate::enabledEngines() const
 {
     unsigned rc = m_cmdLineEnabledEngines;
 #ifdef CDB_ENABLED
-    if (!Internal::isCdbEngineEnabled() && !Cdb::isCdbEngineEnabled())
+    if (!isCdbEngineEnabled() && !Cdb::isCdbEngineEnabled())
         rc &= ~CdbEngineType;
 #endif
     return rc;
 }
 
-DebuggerRunnerPrivate::DebuggerRunnerPrivate(RunConfiguration *runConfiguration,
-                                             unsigned enabledEngines) :
-      m_engine(0)
+DebuggerRunControlPrivate::DebuggerRunControlPrivate(DebuggerRunControl *parent,
+        RunConfiguration *runConfiguration, unsigned enabledEngines)
+    : q(parent)
+    , m_engine(0)
     , m_myRunConfiguration(runConfiguration)
     , m_running(false)
     , m_cmdLineEnabledEngines(enabledEngines)
 {
 }
 
+// Figure out the debugger type of an executable. Analyze executable
+// unless the toolchain provides a hint.
+DebuggerEngineType DebuggerRunControlPrivate::engineForExecutable
+    (unsigned enabledEngineTypes, const QString &executable)
+{
+    /*if (executable.endsWith(_("qmlviewer"))) {
+        if (enabledEngineTypes & QmlEngineType)
+            return QmlEngineType;
+        d->m_errorMessage = msgEngineNotAvailable("Qml Engine");
+    }*/
+
+    if (executable.endsWith(_(".js"))) {
+        if (enabledEngineTypes & ScriptEngineType)
+            return ScriptEngineType;
+        m_errorMessage = msgEngineNotAvailable("Script Engine");
+    }
+
+    if (executable.endsWith(_(".py"))) {
+        if (enabledEngineTypes & PdbEngineType)
+            return PdbEngineType;
+        m_errorMessage = msgEngineNotAvailable("Pdb Engine");
+    }
+
+#ifdef Q_OS_WIN
+    // A remote executable?
+    if (!executable.endsWith(_(".exe")))
+        return GdbEngineType;
+
+    // If a file has PDB files, it has been compiled by VS.
+    QStringList pdbFiles;
+    if (!getPDBFiles(executable, &pdbFiles, &m_errorMessage)) {
+        qWarning("Cannot determine type of executable %s: %s",
+                 qPrintable(executable), qPrintable(m_errorMessage));
+        return NoEngineType;
+    }
+    if (pdbFiles.empty())
+        return GdbEngineType;
+
+    // We need the CDB debugger in order to be able to debug VS
+    // executables
+    if (checkDebugConfiguration(ProjectExplorer::ToolChain_MSVC, &m_errorMessage, 0, &m_settingsIdHint)) {
+        if (enabledEngineTypes & CdbEngineType)
+            return CdbEngineType;
+        m_errorMessage = msgEngineNotAvailable("Cdb Engine");
+        return NoEngineType;
+    }
+#else
+    if (enabledEngineTypes & GdbEngineType)
+        return GdbEngineType;
+    m_errorMessage = msgEngineNotAvailable("Gdb Engine");
+#endif
+
+    return NoEngineType;
+}
+
+// Debugger type for mode.
+DebuggerEngineType DebuggerRunControlPrivate::engineForMode
+    (unsigned enabledEngineTypes, DebuggerStartMode startMode)
+{
+    if (startMode == AttachTcf)
+        return TcfEngineType;
+
+#ifdef Q_OS_WIN
+    // Preferably Windows debugger for attaching locally.
+    if (startMode != AttachToRemote && (enabledEngineTypes & CdbEngineType))
+        return CdbEngineType;
+    if (startMode == AttachCrashedExternal) {
+        m_errorMessage = tr("There is no debugging engine available for post-mortem debugging.");
+        return NoEngineType;
+    }
+    return GdbEngineType;
+#else
+    Q_UNUSED(startMode)
+    Q_UNUSED(enabledEngineTypes)
+    //  >m_errorMessage = msgEngineNotAvailable("Gdb Engine");
+    return GdbEngineType;
+#endif
+}
+
+void DebuggerRunControlPrivate::initGdbEngine(GdbEngine *engine)
+{
+    QTC_ASSERT(engine, return)
+
+    // Forward adapter signals.
+    AbstractGdbAdapter *adapter = engine->gdbAdapter();
+    RemotePlainGdbAdapter *rpga = qobject_cast<RemotePlainGdbAdapter *>(adapter);
+    RemoteGdbServerAdapter *rgsa = qobject_cast<RemoteGdbServerAdapter *>(adapter);
+    if (rpga)
+        q->connect(rpga, SIGNAL(requestSetup()), SIGNAL(engineRequestSetup()));
+    else if (rgsa)
+        q->connect(rgsa, SIGNAL(requestSetup()), SIGNAL(engineRequestSetup()));
+}
+
+GdbEngine *DebuggerRunControlPrivate::gdbEngine() const
+{
+    QTC_ASSERT(m_engine, return 0);
+    if (GdbEngine *gdbEngine = qobject_cast<GdbEngine *>(m_engine))
+        return gdbEngine;
+    if (QmlCppEngine *qmlEngine = qobject_cast<QmlCppEngine *>(m_engine))
+        if (GdbEngine *embeddedGdbEngine = qobject_cast<GdbEngine *>(qmlEngine->cppEngine()))
+            return embeddedGdbEngine;
+    return 0;
+}
+
+AbstractGdbAdapter *DebuggerRunControlPrivate::gdbAdapter() const
+{
+    GdbEngine *engine = gdbEngine();
+    QTC_ASSERT(engine, return 0)
+    return engine->gdbAdapter();
+}
+
+////////////////////////////////////////////////////////////////////////
+//
+// DebuggerRunControl
+//
+////////////////////////////////////////////////////////////////////////
+
 DebuggerRunControl::DebuggerRunControl(RunConfiguration *runConfiguration,
         unsigned enabledEngines, const DebuggerStartParameters &sp)
     : RunControl(runConfiguration, Constants::DEBUGMODE),
-      d(new DebuggerRunnerPrivate(runConfiguration, enabledEngines))
+      d(new DebuggerRunControlPrivate(this, runConfiguration, enabledEngines))
 {
-    connect(this, SIGNAL(finished()), this, SLOT(handleFinished()));
-    DebuggerStartParameters startParams = sp;
-    createEngine(startParams);
+    connect(this, SIGNAL(finished()), SLOT(handleFinished()));
+    createEngine(sp);
 }
 
 DebuggerRunControl::~DebuggerRunControl()
@@ -334,84 +465,6 @@ static DebuggerEngineType engineForToolChain(int toolChainType)
     return NoEngineType;
 }
 
-
-// Figure out the debugger type of an executable. Analyze executable
-// unless the toolchain provides a hint.
-DebuggerEngineType DebuggerRunControl::engineForExecutable(unsigned enabledEngineTypes, const QString &executable)
-{
-    /*if (executable.endsWith(_("qmlviewer"))) {
-        if (enabledEngineTypes & QmlEngineType)
-            return QmlEngineType;
-        d->m_errorMessage = msgEngineNotAvailable("Qml Engine");
-    }*/
-
-    if (executable.endsWith(_(".js"))) {
-        if (enabledEngineTypes & ScriptEngineType)
-            return ScriptEngineType;
-        d->m_errorMessage = msgEngineNotAvailable("Script Engine");
-    }
-
-    if (executable.endsWith(_(".py"))) {
-        if (enabledEngineTypes & PdbEngineType)
-            return PdbEngineType;
-        d->m_errorMessage = msgEngineNotAvailable("Pdb Engine");
-    }
-
-#ifdef Q_OS_WIN
-    // A remote executable?
-    if (!executable.endsWith(_(".exe")))
-        return GdbEngineType;
-
-    // If a file has PDB files, it has been compiled by VS.
-    QStringList pdbFiles;
-    if (!getPDBFiles(executable, &pdbFiles, &d->m_errorMessage)) {
-        qWarning("Cannot determine type of executable %s: %s",
-                 qPrintable(executable), qPrintable(d->m_errorMessage));
-        return NoEngineType;
-    }
-    if (pdbFiles.empty())
-        return GdbEngineType;
-
-    // We need the CDB debugger in order to be able to debug VS
-    // executables
-    if (checkDebugConfiguration(ProjectExplorer::ToolChain_MSVC, &d->m_errorMessage, 0, &d->m_settingsIdHint)) {
-        if (enabledEngineTypes & CdbEngineType)
-            return CdbEngineType;
-        d->m_errorMessage = msgEngineNotAvailable("Cdb Engine");
-        return NoEngineType;
-    }
-#else
-    if (enabledEngineTypes & GdbEngineType)
-        return GdbEngineType;
-    d->m_errorMessage = msgEngineNotAvailable("Gdb Engine");
-#endif
-
-    return NoEngineType;
-}
-
-// Debugger type for mode.
-DebuggerEngineType DebuggerRunControl::engineForMode(unsigned enabledEngineTypes, DebuggerStartMode startMode)
-{
-    if (startMode == AttachTcf)
-        return TcfEngineType;
-
-#ifdef Q_OS_WIN
-    // Preferably Windows debugger for attaching locally.
-    if (startMode != AttachToRemote && (enabledEngineTypes & CdbEngineType))
-        return CdbEngineType;
-    if (startMode == AttachCrashedExternal) {
-        d->m_errorMessage = tr("There is no debugging engine available for post-mortem debugging.");
-        return NoEngineType;
-    }
-    return GdbEngineType;
-#else
-    Q_UNUSED(startMode)
-    Q_UNUSED(enabledEngineTypes)
-    //  d->m_errorMessage = msgEngineNotAvailable("Gdb Engine");
-    return GdbEngineType;
-#endif
-}
-
 void DebuggerRunControl::createEngine(const DebuggerStartParameters &startParams)
 {
     DebuggerStartParameters sp = startParams;
@@ -437,15 +490,15 @@ void DebuggerRunControl::createEngine(const DebuggerStartParameters &startParams
         engineType = GdbEngineType;
 
     if (sp.processArgs.contains( _("@lldb@")))
-        engineType = LLDBEngineType;
+        engineType = LldbEngineType;
 
     if (engineType == NoEngineType
             && sp.startMode != AttachToRemote
             && !sp.executable.isEmpty())
-        engineType = engineForExecutable(enabledEngineTypes, sp.executable);
+        engineType = d->engineForExecutable(enabledEngineTypes, sp.executable);
 
     if (engineType == NoEngineType)
-        engineType = engineForMode(enabledEngineTypes, sp.startMode);
+        engineType = d->engineForMode(enabledEngineTypes, sp.startMode);
 
     if ((engineType != QmlEngineType && engineType != NoEngineType)
         && (activeLangs & QmlLanguage)) {
@@ -462,10 +515,10 @@ void DebuggerRunControl::createEngine(const DebuggerStartParameters &startParams
     switch (engineType) {
         case GdbEngineType:
             d->m_engine = createGdbEngine(sp);
-            initGdbEngine(qobject_cast<Internal::GdbEngine *>(d->m_engine));
+            d->initGdbEngine(qobject_cast<GdbEngine *>(d->m_engine));
             break;
         case ScriptEngineType:
-            d->m_engine = Internal::createScriptEngine(sp);
+            d->m_engine = createScriptEngine(sp);
             break;
         case CdbEngineType:
             // Try new engine, fall back to old.
@@ -476,24 +529,24 @@ void DebuggerRunControl::createEngine(const DebuggerStartParameters &startParams
             }
             break;
         case PdbEngineType:
-            d->m_engine = Internal::createPdbEngine(sp);
+            d->m_engine = createPdbEngine(sp);
             break;
         case TcfEngineType:
-            d->m_engine = Internal::createTcfEngine(sp);
+            d->m_engine = createTcfEngine(sp);
             break;
         case QmlEngineType:
-            d->m_engine = Internal::createQmlEngine(sp);
+            d->m_engine = createQmlEngine(sp);
             connect(qobject_cast<QmlEngine *>(d->m_engine),
-                SIGNAL(remoteStartupRequested()), this,
+                SIGNAL(remoteStartupRequested()),
                 SIGNAL(engineRequestSetup()));
             break;
         case QmlCppEngineType:
-            d->m_engine = Internal::createQmlCppEngine(sp);
-            if (Internal::GdbEngine *embeddedGdbEngine = gdbEngine())
-                initGdbEngine(embeddedGdbEngine);
+            d->m_engine = createQmlCppEngine(sp);
+            if (GdbEngine *embeddedGdbEngine = d->gdbEngine())
+                d->initGdbEngine(embeddedGdbEngine);
             break;
-        case LLDBEngineType:
-            d->m_engine = Internal::createLLDBEngine(sp);
+        case LldbEngineType:
+            d->m_engine = createLldbEngine(sp);
        case NoEngineType:
        case AllEngineTypes:
             break;
@@ -511,21 +564,6 @@ void DebuggerRunControl::createEngine(const DebuggerStartParameters &startParams
     }
 }
 
-void DebuggerRunControl::initGdbEngine(Internal::GdbEngine *engine)
-{
-    QTC_ASSERT(engine, return)
-
-    // Forward adapter signals.
-    Internal::AbstractGdbAdapter *adapter = engine->gdbAdapter();
-    if (RemotePlainGdbAdapter *rpga = qobject_cast<RemotePlainGdbAdapter *>(adapter)) {
-        connect(rpga, SIGNAL(requestSetup()), this,
-                SIGNAL(engineRequestSetup()));
-    } else if (RemoteGdbServerAdapter *rgsa = qobject_cast<RemoteGdbServerAdapter *>(adapter)) {
-        connect(rgsa, SIGNAL(requestSetup()),
-                this, SIGNAL(engineRequestSetup()));
-    }
-}
-
 QString DebuggerRunControl::displayName() const
 {
     QTC_ASSERT(d->m_engine, return QString());
@@ -703,56 +741,54 @@ DebuggerEngine *DebuggerRunControl::engine()
     return d->m_engine;
 }
 
-Internal::GdbEngine *DebuggerRunControl::gdbEngine() const
-{
-    QTC_ASSERT(d->m_engine, return 0);
-    if (GdbEngine *gdbEngine = qobject_cast<GdbEngine *>(d->m_engine))
-        return gdbEngine;
-    if (QmlCppEngine * const qmlEngine = qobject_cast<QmlCppEngine *>(d->m_engine))
-        if (Internal::GdbEngine *embeddedGdbEngine = qobject_cast<GdbEngine *>(qmlEngine->cppEngine()))
-            return embeddedGdbEngine;
-    return 0;
-}
-
-Internal::AbstractGdbAdapter *DebuggerRunControl::gdbAdapter() const
-{
-    GdbEngine *engine = gdbEngine();
-    QTC_ASSERT(engine, return 0)
-    return engine->gdbAdapter();
-}
-
 void DebuggerRunControl::handleRemoteSetupDone(int gdbServerPort, int qmlPort)
 {
+    // FIXME: Use virtual functions?
     if (QmlEngine *qmlEngine = qobject_cast<QmlEngine *>(d->m_engine)) {
         qmlEngine->handleRemoteSetupDone(qmlPort);
-    } else if (Internal::AbstractGdbAdapter *adapter = gdbAdapter()) {
-        if (RemotePlainGdbAdapter *rpga = qobject_cast<RemotePlainGdbAdapter *>(adapter)) {
-            rpga->handleSetupDone(qmlPort);
-        } else if (RemoteGdbServerAdapter *rgsa = qobject_cast<RemoteGdbServerAdapter *>(adapter)) {
-            rgsa->handleSetupDone(gdbServerPort, qmlPort);
-        } else {
-            QTC_ASSERT(false, /* */ );
-        }
-    } else {
-        QTC_ASSERT(false, /* */ );
+        return;
     }
+
+    AbstractGdbAdapter *adapter = d->gdbAdapter();
+    QTC_ASSERT(adapter, return);
+
+    RemotePlainGdbAdapter *rpga = qobject_cast<RemotePlainGdbAdapter *>(adapter);
+    if (rpga) {
+        rpga->handleSetupDone(qmlPort);
+        return;
+    }
+
+    RemoteGdbServerAdapter *rgsa = qobject_cast<RemoteGdbServerAdapter *>(adapter);
+    if (rgsa) {
+        rgsa->handleSetupDone(gdbServerPort, qmlPort);
+        return;
+    }
+    QTC_ASSERT(false, /**/);
 }
 
 void DebuggerRunControl::handleRemoteSetupFailed(const QString &message)
 {
+    // FIXME: Use virtual functions?
     if (QmlEngine *qmlEngine = qobject_cast<QmlEngine *>(d->m_engine)) {
         qmlEngine->handleRemoteSetupFailed(message);
-    } else if (Internal::AbstractGdbAdapter *adapter = gdbAdapter()) {
-        if (RemotePlainGdbAdapter *rpga = qobject_cast<RemotePlainGdbAdapter *>(adapter)) {
-            rpga->handleSetupFailed(message);
-        } else if (RemoteGdbServerAdapter *rgsa = qobject_cast<RemoteGdbServerAdapter *>(adapter)) {
-            rgsa->handleSetupFailed(message);
-        } else {
-            QTC_ASSERT(false, /* */ );
-        }
-    } else {
-        QTC_ASSERT(false, /* */ );
+        return;
     }
+
+    AbstractGdbAdapter *adapter = d->gdbAdapter();
+    QTC_ASSERT(adapter, return);
+
+    RemotePlainGdbAdapter *rpga = qobject_cast<RemotePlainGdbAdapter *>(adapter);
+    if (rpga) {
+        rpga->handleSetupFailed(message);
+        return;
+    }
+
+    RemoteGdbServerAdapter *rgsa = qobject_cast<RemoteGdbServerAdapter *>(adapter);
+    if (rgsa) {
+        rgsa->handleSetupFailed(message);
+        return;
+    }
+    QTC_ASSERT(false, /**/);
 }
 
 void DebuggerRunControl::emitAddToOutputWindow(const QString &line, bool onStdErr)

src/plugins/debugger/debuggerrunner.h

@@ -44,9 +44,8 @@ class Environment;
 namespace Debugger {
 class DebuggerEngine;
 class DebuggerRunControl;
-class QmlEngine;
+class DebuggerRunControlPrivate;
 class DebuggerStartParameters;
-struct DebuggerRunnerPrivate;
 
 namespace Internal {
 class GdbEngine;
@@ -101,9 +100,7 @@ public:
     QString displayName() const;
 
     void createEngine(const DebuggerStartParameters &startParameters);
-
     void setCustomEnvironment(Utils::Environment env);
-
     void startFailed();
     void debuggingFinished();
     RunConfiguration *runConfiguration() const;
@@ -136,13 +133,7 @@ protected:
     const DebuggerStartParameters &startParameters() const;
 
 private:
-    DebuggerEngineType engineForExecutable(unsigned enabledEngineTypes, const QString &executable);
-    DebuggerEngineType engineForMode(unsigned enabledEngineTypes, DebuggerStartMode mode);
-    void initGdbEngine(Internal::GdbEngine *engine);
-    Internal::GdbEngine *gdbEngine() const;
-    Internal::AbstractGdbAdapter *gdbAdapter() const;
-
-    QScopedPointer<DebuggerRunnerPrivate> d;
+    QScopedPointer<DebuggerRunControlPrivate> d;
 };
 
 } // namespace Debugger

src/plugins/debugger/lldb/guest/lldbengineguest.cpp

@@ -68,7 +68,7 @@
 namespace Debugger {
 namespace Internal {
 
-void LLDBEventListener::listen(lldb::SBListener *listener)
+void LldbEventListener::listen(lldb::SBListener *listener)
 {
     while (true) {
         lldb::SBEvent event;
@@ -77,11 +77,11 @@ void LLDBEventListener::listen(lldb::SBListener *listener)
     }
 }
 
-LLDBEngineGuest::LLDBEngineGuest()
+LldbEngineGuest::LldbEngineGuest()
     : IPCEngineGuest()
     , m_runLock (QMutex::Recursive)
     , m_running (false)
-    , m_worker  (new LLDBEventListener)
+    , m_worker  (new LldbEventListener)
     , m_lldb    (new lldb::SBDebugger)
     , m_target  (new lldb::SBTarget)
     , m_process (new lldb::SBProcess)
@@ -101,7 +101,7 @@ LLDBEngineGuest::LLDBEngineGuest()
     setObjectName(QLatin1String("LLDBEngineGuest"));
 }
 
-LLDBEngineGuest::~LLDBEngineGuest()
+LldbEngineGuest::~LldbEngineGuest()
 {
     delete m_lldb;
     delete m_target;
@@ -109,7 +109,7 @@ LLDBEngineGuest::~LLDBEngineGuest()
     delete m_listener;
 }
 
-void LLDBEngineGuest::setupEngine()
+void LldbEngineGuest::setupEngine()
 {
     DEBUG_FUNC_ENTER;
 
@@ -124,7 +124,7 @@ void LLDBEngineGuest::setupEngine()
 
 }
 
-void LLDBEngineGuest::setupInferior(const QString &executable,
+void LldbEngineGuest::setupInferior(const QString &executable,
         const QStringList &args, const QStringList &env)
 {
     DEBUG_FUNC_ENTER;
@@ -146,17 +146,17 @@ void LLDBEngineGuest::setupInferior(const QString &executable,
     notifyInferiorSetupOk();
 }
 
-void LLDBEngineGuest::runEngine()
+void LldbEngineGuest::runEngine()
 {
     DEBUG_FUNC_ENTER;
 
-    const char **argp = new const char * [m_arguments.count() + 1];
+    const char **argp = new const char *[m_arguments.count() + 1];
     argp[m_arguments.count()] = 0;
     for (int i = 0; i < m_arguments.count(); i++) {
         argp[i] = m_arguments[i].data();
     }
 
-    const char **envp = new const char * [m_environment.count() + 1];
+    const char **envp = new const char *[m_environment.count() + 1];
     envp[m_environment.count()] = 0;
     for (int i = 0; i < m_environment.count(); i++) {
         envp[i] = m_environment[i].data();
@@ -178,13 +178,13 @@ void LLDBEngineGuest::runEngine()
             Q_ARG(lldb::SBListener *, m_listener));
 }
 
-void LLDBEngineGuest::shutdownInferior()
+void LldbEngineGuest::shutdownInferior()
 {
     DEBUG_FUNC_ENTER;
     m_process->Kill();
 }
 
-void LLDBEngineGuest::shutdownEngine()
+void LldbEngineGuest::shutdownEngine()
 {
     DEBUG_FUNC_ENTER;
     m_currentFrame = lldb::SBFrame();
@@ -202,12 +202,12 @@ void LLDBEngineGuest::shutdownEngine()
     notifyEngineShutdownOk();
 }
 
-void LLDBEngineGuest::detachDebugger()
+void LldbEngineGuest::detachDebugger()
 {
     DEBUG_FUNC_ENTER;
 }
 
-void LLDBEngineGuest::executeStep()
+void LldbEngineGuest::executeStep()
 {
     DEBUG_FUNC_ENTER;
 
@@ -216,7 +216,7 @@ void LLDBEngineGuest::executeStep()
     m_currentThread.StepInto();
 }
 
-void LLDBEngineGuest::executeStepOut()
+void LldbEngineGuest::executeStepOut()
 {
     DEBUG_FUNC_ENTER;
 
@@ -227,7 +227,7 @@ void LLDBEngineGuest::executeStepOut()
     notifyInferiorRunOk();
 }
 
-void LLDBEngineGuest::executeNext()
+void LldbEngineGuest::executeNext()
 {
     DEBUG_FUNC_ENTER;
 
@@ -238,7 +238,7 @@ void LLDBEngineGuest::executeNext()
     notifyInferiorRunOk();
 }
 
-void LLDBEngineGuest::executeStepI()
+void LldbEngineGuest::executeStepI()
 {
     DEBUG_FUNC_ENTER;
 
@@ -247,7 +247,7 @@ void LLDBEngineGuest::executeStepI()
     m_currentThread.StepInstruction(false);
 }
 
-void LLDBEngineGuest::executeNextI()
+void LldbEngineGuest::executeNextI()
 {
     DEBUG_FUNC_ENTER;
 
@@ -258,7 +258,7 @@ void LLDBEngineGuest::executeNextI()
     notifyInferiorRunOk();
 }
 
-void LLDBEngineGuest::continueInferior()
+void LldbEngineGuest::continueInferior()
 {
     DEBUG_FUNC_ENTER;
 
@@ -266,7 +266,7 @@ void LLDBEngineGuest::continueInferior()
     m_process->Continue();
     showStatusMessage(QLatin1String("resuming inferior"));
 }
-void LLDBEngineGuest::interruptInferior()
+void LldbEngineGuest::interruptInferior()
 {
     DEBUG_FUNC_ENTER;
 
@@ -276,7 +276,7 @@ void LLDBEngineGuest::interruptInferior()
     updateThreads();
 }
 
-void LLDBEngineGuest::executeRunToLine(const QString &fileName, int lineNumber)
+void LldbEngineGuest::executeRunToLine(const QString &fileName, int lineNumber)
 {
     DEBUG_FUNC_ENTER;
 
@@ -285,14 +285,14 @@ void LLDBEngineGuest::executeRunToLine(const QString &fileName, int lineNumber)
     Q_UNUSED(lineNumber);
 }
 
-void LLDBEngineGuest::executeRunToFunction(const QString &functionName)
+void LldbEngineGuest::executeRunToFunction(const QString &functionName)
 {
     DEBUG_FUNC_ENTER;
 
     // TODO
     Q_UNUSED(functionName);
 }
-void LLDBEngineGuest::executeJumpToLine(const QString &fileName, int lineNumber)
+void LldbEngineGuest::executeJumpToLine(const QString &fileName, int lineNumber)
 {
     DEBUG_FUNC_ENTER;
 
@@ -301,7 +301,7 @@ void LLDBEngineGuest::executeJumpToLine(const QString &fileName, int lineNumber)
     Q_UNUSED(lineNumber);
 }
 
-void LLDBEngineGuest::activateFrame(qint64 token)
+void LldbEngineGuest::activateFrame(qint64 token)
 {
     DEBUG_FUNC_ENTER;
     SYNC_INFERIOR;
@@ -324,7 +324,7 @@ void LLDBEngineGuest::activateFrame(qint64 token)
     updateWatchData(true, wd);
 }
 
-void LLDBEngineGuest::requestUpdateWatchData(const Internal::WatchData &data,
+void LldbEngineGuest::requestUpdateWatchData(const Internal::WatchData &data,
         const Internal::WatchUpdateFlags &)
 {
     DEBUG_FUNC_ENTER;
@@ -339,7 +339,7 @@ void LLDBEngineGuest::requestUpdateWatchData(const Internal::WatchData &data,
     updateWatchData(false, wd);
 }
 
-void LLDBEngineGuest::getWatchDataR(lldb::SBValue v, int level,
+void LldbEngineGuest::getWatchDataR(lldb::SBValue v, int level,
         const QByteArray &p_iname, QList<WatchData> &wd)
 {
     QByteArray iname = p_iname + "." + QByteArray(v.GetName());
@@ -366,7 +366,7 @@ void LLDBEngineGuest::getWatchDataR(lldb::SBValue v, int level,
     }
 }
 
-void LLDBEngineGuest::disassemble(quint64 pc)
+void LldbEngineGuest::disassemble(quint64 pc)
 {
     DEBUG_FUNC_ENTER;
     SYNC_INFERIOR_OR(return);
@@ -386,7 +386,7 @@ void LLDBEngineGuest::disassemble(quint64 pc)
     }
 }
 
-void LLDBEngineGuest::addBreakpoint(BreakpointId id,
+void LldbEngineGuest::addBreakpoint(BreakpointId id,
         const Internal::BreakpointParameters &bp_)
 {
     DEBUG_FUNC_ENTER;
@@ -422,7 +422,7 @@ void LLDBEngineGuest::addBreakpoint(BreakpointId id,
     }
 }
 
-void LLDBEngineGuest::removeBreakpoint(BreakpointId id)
+void LldbEngineGuest::removeBreakpoint(BreakpointId id)
 {
     DEBUG_FUNC_ENTER;
     SYNC_INFERIOR_OR(notifyRemoveBreakpointFailed(id); return);
@@ -432,7 +432,7 @@ void LLDBEngineGuest::removeBreakpoint(BreakpointId id)
     notifyRemoveBreakpointOk(id);
 }
 
-void LLDBEngineGuest::changeBreakpoint(BreakpointId id,
+void LldbEngineGuest::changeBreakpoint(BreakpointId id,
         const Internal::BreakpointParameters &bp)
 {
     DEBUG_FUNC_ENTER;
@@ -442,7 +442,7 @@ void LLDBEngineGuest::changeBreakpoint(BreakpointId id,
     Q_UNUSED(bp);
 }
 
-void LLDBEngineGuest::selectThread(qint64 token)
+void LldbEngineGuest::selectThread(qint64 token)
 {
     DEBUG_FUNC_ENTER;
     SYNC_INFERIOR_OR(return);
@@ -535,7 +535,7 @@ void LLDBEngineGuest::selectThread(qint64 token)
     }
 }
 
-void LLDBEngineGuest::updateThreads()
+void LldbEngineGuest::updateThreads()
 {
     DEBUG_FUNC_ENTER;
     SYNC_INFERIOR_OR(return);
@@ -646,7 +646,7 @@ void LLDBEngineGuest::updateThreads()
     }
 }
 
-void LLDBEngineGuest::lldbEvent(lldb::SBEvent *ev)
+void LldbEngineGuest::lldbEvent(lldb::SBEvent *ev)
 {
     qDebug() << "lldbevent" << ev->GetType() <<
         ev->GetDataFlavor() << m_process->GetState() << (int)state();

src/plugins/debugger/lldb/guest/lldbengineguest.h

@@ -50,7 +50,7 @@ Q_DECLARE_METATYPE (lldb::SBEvent *)
 namespace Debugger {
 namespace Internal {
 
-class LLDBEventListener : public QObject
+class LldbEventListener : public QObject
 {
 Q_OBJECT
 public slots:
@@ -63,13 +63,13 @@ signals:
 };
 
 
-class LLDBEngineGuest : public IPCEngineGuest
+class LldbEngineGuest : public IPCEngineGuest
 {
     Q_OBJECT
 
 public:
-    explicit LLDBEngineGuest();
-    ~LLDBEngineGuest();
+    explicit LldbEngineGuest();
+    ~LldbEngineGuest();
 
     void setupEngine();
     void setupInferior(const QString &executable, const QStringList &arguments,
@@ -95,9 +95,8 @@ public:
     void removeBreakpoint(BreakpointId id);
     void changeBreakpoint(BreakpointId id, const BreakpointParameters &bp);
 
-    void requestUpdateWatchData(const Internal::WatchData &data,
-            const Internal::WatchUpdateFlags & flags = Internal::WatchUpdateFlags());
-
+    void requestUpdateWatchData(const WatchData &data,
+            const WatchUpdateFlags &flags);
 
 private:
     QMutex m_runLock;
@@ -106,7 +105,7 @@ private:
     QList<QByteArray> m_arguments;
     QList<QByteArray> m_environment;
     QThread m_wThread;
-    LLDBEventListener *m_worker;
+    LldbEventListener *m_worker;
     lldb::SBDebugger *m_lldb;
     lldb::SBTarget   *m_target;
     lldb::SBProcess  *m_process;
@@ -130,8 +129,6 @@ private slots:
     void lldbEvent(lldb::SBEvent *ev);
 };
 
-
-
 } // namespace Internal
 } // namespace Debugger
 

src/plugins/debugger/lldb/guest/main.cpp

@@ -16,7 +16,7 @@ int main(int argc, char **argv)
     QCoreApplication app(argc, argv);
 
 
-    Debugger::Internal::LLDBEngineGuest lldb;
+    Debugger::Internal::LldbEngineGuest lldb;
 
     QLocalSocket s;
     if (argc > 1) {

src/plugins/debugger/lldb/ipcengineguest.cpp

@@ -62,23 +62,23 @@ IPCEngineGuest::~IPCEngineGuest()
 {
 }
 
-void IPCEngineGuest::setLocalHost(IPCEngineHost * h)
+void IPCEngineGuest::setLocalHost(IPCEngineHost *host)
 {
-    m_local_host = h;
+    m_local_host = host;
 }
 
-void IPCEngineGuest::setHostDevice(QIODevice * d)
+void IPCEngineGuest::setHostDevice(QIODevice *device)
 {
     if (m_device) {
-        disconnect(m_device, SIGNAL(readyRead()), this, SLOT(readyRead()));
+        disconnect(m_device, SIGNAL(readyRead()), SLOT(readyRead()));
         delete m_device;
     }
-    m_device = d;
+    m_device = device;
     if (m_device)
-        connect(m_device, SIGNAL(readyRead()), this, SLOT(readyRead()));
+        connect(m_device, SIGNAL(readyRead()), SLOT(readyRead()));
 }
 
-void IPCEngineGuest::rpcCall(IPCEngineGuest::Function f, QByteArray payload )
+void IPCEngineGuest::rpcCall(Function f, QByteArray payload)
 {
 #if 0
     if (m_local_host) {
@@ -105,7 +105,7 @@ void IPCEngineGuest::rpcCall(IPCEngineGuest::Function f, QByteArray payload )
 void IPCEngineGuest::readyRead()
 {
     if (!m_nextMessagePayloadSize) {
-        if (quint64(m_device->bytesAvailable()) < (sizeof(quint64) * 3))
+        if (quint64(m_device->bytesAvailable()) < 3 * sizeof(quint64))
             return;
         QDataStream s(m_device);
         SET_NATIVE_BYTE_ORDER(s);
@@ -119,7 +119,7 @@ void IPCEngineGuest::readyRead()
     if (ba < m_nextMessagePayloadSize)
         return;
 
-    qint64 rrr = (m_nextMessagePayloadSize);
+    qint64 rrr = m_nextMessagePayloadSize;
     QByteArray payload = m_device->read(rrr);
     if (quint64(payload.size()) != m_nextMessagePayloadSize || !payload.endsWith('T')) {
         showMessage(QLatin1String("IPC Error: corrupted frame"));
@@ -132,7 +132,7 @@ void IPCEngineGuest::readyRead()
     rpcCallback(m_nextMessageFunction, payload);
     m_nextMessagePayloadSize = 0;
 
-    if (quint64(m_device->bytesAvailable ()) >= (sizeof(quint64) * 3))
+    if (quint64(m_device->bytesAvailable ()) >= 3 * sizeof(quint64) * 3)
         QTimer::singleShot(0, this, SLOT(readyRead()));
 }
 
@@ -601,7 +601,7 @@ void IPCEngineGuest::updateWatchData(bool fullCycle, const QList<WatchData> &wd)
         SET_NATIVE_BYTE_ORDER(s);
         s << fullCycle;
         s << quint64(wd.count());
-        for (int i = 0; i < wd.count(); i++)
+        for (int i = 0; i < wd.count(); ++i)
             s << wd.at(i);
     }
     rpcCall(UpdateWatchData, p);

src/plugins/debugger/lldb/ipcenginehost.cpp

@@ -58,12 +58,12 @@ namespace Internal {
 
 IPCEngineHost::IPCEngineHost (const DebuggerStartParameters &startParameters)
     : DebuggerEngine(startParameters)
-    , m_local_guest(0)
+    , m_localGuest(0)
     , m_nextMessagePayloadSize(0)
     , m_cookie(1)
     , m_device(0)
 {
-    connect(this, SIGNAL(stateChanged(DebuggerState)), this, SLOT(m_stateChanged(DebuggerState)));
+    connect(this, SIGNAL(stateChanged(DebuggerState)), SLOT(m_stateChanged(DebuggerState)));
 }
 
 IPCEngineHost::~IPCEngineHost()
@@ -71,18 +71,18 @@ IPCEngineHost::~IPCEngineHost()
     delete m_device;
 }
 
-void IPCEngineHost::setLocalGuest(IPCEngineGuest *g)
+void IPCEngineHost::setLocalGuest(IPCEngineGuest *guest)
 {
-    m_local_guest = g;
+    m_localGuest = guest;
 }
 
-void IPCEngineHost::setGuestDevice(QIODevice *d)
+void IPCEngineHost::setGuestDevice(QIODevice *device)
 {
     if (m_device) {
         disconnect(m_device, SIGNAL(readyRead()), this, SLOT(readyRead()));
         delete m_device;
     }
-    m_device = d;
+    m_device = device;
     if (m_device)
         connect(m_device, SIGNAL(readyRead()), this, SLOT(readyRead()));
 }
@@ -461,7 +461,7 @@ void IPCEngineHost::rpcCallback(quint64 f, QByteArray payload)
                 QList<WatchData> wd;
                 s >> fullCycle;
                 s >> count;
-                for (qint64 i = 0; i < count; i++) {
+                for (qint64 i = 0; i < count; ++i) {
                     WatchData d;
                     s >> d;
                     wd.append(d);
@@ -548,8 +548,8 @@ void IPCEngineHost::m_stateChanged(const DebuggerState &state)
 
 void IPCEngineHost::rpcCall(Function f, QByteArray payload)
 {
-    if (m_local_guest) {
-        QMetaObject::invokeMethod(m_local_guest,
+    if (m_localGuest) {
+        QMetaObject::invokeMethod(m_localGuest,
                 "rpcCallback",
                 Qt::QueuedConnection,
                 Q_ARG(quint64, f),
@@ -574,12 +574,12 @@ void IPCEngineHost::readyRead()
     QDataStream s(m_device);
     SET_NATIVE_BYTE_ORDER(s);
     if (!m_nextMessagePayloadSize) {
-        if (quint64(m_device->bytesAvailable ()) < (sizeof(quint64) * 3))
+        if (quint64(m_device->bytesAvailable ()) < 3 * sizeof(quint64))
             return;
         s >> m_nextMessageCookie;
         s >> m_nextMessageFunction;
         s >> m_nextMessagePayloadSize;
-        m_nextMessagePayloadSize += 1; // terminator and "got header" marker
+        m_nextMessagePayloadSize += 1; // Terminator and "got header" marker.
     }
 
     quint64 ba = m_device->bytesAvailable();
@@ -598,11 +598,10 @@ void IPCEngineHost::readyRead()
     }
     rpcCallback(m_nextMessageFunction, payload);
     m_nextMessagePayloadSize = 0;
-    if (quint64(m_device->bytesAvailable()) >= (sizeof(quint64) * 3))
+    if (quint64(m_device->bytesAvailable()) >= 3 * sizeof(quint64))
         QTimer::singleShot(0, this, SLOT(readyRead()));
 }
 
-
 } // namespace Internal
 } // namespace Debugger
 

src/plugins/debugger/lldb/ipcenginehost.h

@@ -118,13 +118,13 @@ private slots:
     void m_stateChanged(const DebuggerState &state);
     void readyRead();
 private:
-    IPCEngineGuest *m_local_guest;
+    IPCEngineGuest *m_localGuest;
     quint64 m_nextMessageCookie;
     quint64 m_nextMessageFunction;
     quint64 m_nextMessagePayloadSize;
     quint64 m_cookie;
     QIODevice *m_device;
-    QHash <quint64, DisassemblerViewAgent *> m_frameToDisassemblerAgent;
+    QHash<quint64, DisassemblerViewAgent *> m_frameToDisassemblerAgent;
 };
 
 } // namespace Internal

src/plugins/debugger/lldb/lldbenginehost.cpp

@@ -60,23 +60,23 @@
 namespace Debugger {
 namespace Internal {
 
-LLDBEngineHost::LLDBEngineHost(const DebuggerStartParameters &startParameters)
+LldbEngineHost::LldbEngineHost(const DebuggerStartParameters &startParameters)
     :IPCEngineHost(startParameters)
 {
     QLocalServer *s = new QLocalServer(this);
-    s->removeServer (QLatin1String("/tmp/qtcreator-debuggeripc"));
-    s->listen (QLatin1String("/tmp/qtcreator-debuggeripc"));
+    s->removeServer(QLatin1String("/tmp/qtcreator-debuggeripc"));
+    s->listen(QLatin1String("/tmp/qtcreator-debuggeripc"));
 
-    m_guestp = new QProcess(this);
-    m_guestp->setProcessChannelMode(QProcess::ForwardedChannels);
+    m_guestProcess = new QProcess(this);
+    m_guestProcess->setProcessChannelMode(QProcess::ForwardedChannels);
 
-    connect(m_guestp, SIGNAL(finished(int, QProcess::ExitStatus)),
-            this, SLOT(finished (int, QProcess::ExitStatus)));
+    connect(m_guestProcess, SIGNAL(finished(int, QProcess::ExitStatus)),
+            this, SLOT(finished(int, QProcess::ExitStatus)));
 
-    QString a(Core::ICore::instance()->resourcePath() + QLatin1String("/qtcreator-lldb"));
-    m_guestp->start(a,QStringList());
+    QString a = Core::ICore::instance()->resourcePath() + QLatin1String("/qtcreator-lldb");
+    m_guestProcess->start(a, QStringList());
 
-    if (!m_guestp->waitForStarted()) {
+    if (!m_guestProcess->waitForStarted()) {
         showStatusMessage(tr("lldb failed to start"));
         notifyEngineIll();
         return;
@@ -88,23 +88,23 @@ LLDBEngineHost::LLDBEngineHost(const DebuggerStartParameters &startParameters)
     setGuestDevice(f);
 }
 
-LLDBEngineHost::~LLDBEngineHost()
+LldbEngineHost::~LldbEngineHost()
 {
-    disconnect(m_guestp, SIGNAL(finished(int, QProcess::ExitStatus)),
+    disconnect(m_guestProcess, SIGNAL(finished(int, QProcess::ExitStatus)),
             this, SLOT(finished (int, QProcess::ExitStatus)));
-    m_guestp->terminate();
-    m_guestp->kill();
+    m_guestProcess->terminate();
+    m_guestProcess->kill();
 }
 
-void LLDBEngineHost::finished(int, QProcess::ExitStatus)
+void LldbEngineHost::finished(int, QProcess::ExitStatus)
 {
     showStatusMessage(QLatin1String("lldb crashed"));
     notifyEngineIll();
 }
 
-DebuggerEngine *createLLDBEngine(const DebuggerStartParameters &startParameters)
+DebuggerEngine *createLldbEngine(const DebuggerStartParameters &startParameters)
 {
-    return new LLDBEngineHost(startParameters);
+    return new LldbEngineHost(startParameters);
 }
 
 } // namespace Internal

src/plugins/debugger/lldb/lldbenginehost.h

@@ -37,19 +37,22 @@
 namespace Debugger {
 namespace Internal {
 
-class LLDBEngineHost : public IPCEngineHost
+class LldbEngineHost : public IPCEngineHost
 {
     Q_OBJECT
+
 public:
-    explicit LLDBEngineHost(const DebuggerStartParameters &startParameters);
-    ~LLDBEngineHost();
+    explicit LldbEngineHost(const DebuggerStartParameters &startParameters);
+    ~LldbEngineHost();
+
 private:
-    QProcess *m_guestp;
+    QProcess *m_guestProcess;
+
 private slots:
-    void finished (int, QProcess::ExitStatus);
+    void finished(int, QProcess::ExitStatus);
 };
 
 } // namespace Internal
 } // namespace Debugger
 
-#endif // DEBUGGER_LLDBENGINE_H
+#endif // DEBUGGER_LLDBENGINE_HOST_H

src/plugins/debugger/qml/qmlcppengine.cpp

@@ -119,7 +119,7 @@ void QmlCppEngine::setActiveEngine(DebuggerLanguage language)
     }
     if (previousEngine != d->m_activeEngine) {
         showStatusMessage(tr("%1 debugger activated").arg(engineName));
-        Internal::debuggerCore()->displayDebugger(d->m_activeEngine, updateEngine);
+        debuggerCore()->displayDebugger(d->m_activeEngine, updateEngine);
     }
 }
 
@@ -138,8 +138,8 @@ void QmlCppEngine::setToolTipExpression(const QPoint & mousePos,
     d->m_activeEngine->setToolTipExpression(mousePos, editor, cursorPos);
 }
 
-void QmlCppEngine::updateWatchData(const Internal::WatchData &data,
-    const Internal::WatchUpdateFlags &flags)
+void QmlCppEngine::updateWatchData(const WatchData &data,
+    const WatchUpdateFlags &flags)
 {
     d->m_activeEngine->updateWatchData(data, flags);
 }
@@ -149,13 +149,13 @@ void QmlCppEngine::watchPoint(const QPoint &point)
     d->m_cppEngine->watchPoint(point);
 }
 
-void QmlCppEngine::fetchMemory(Internal::MemoryViewAgent *mva, QObject *obj,
+void QmlCppEngine::fetchMemory(MemoryViewAgent *mva, QObject *obj,
         quint64 addr, quint64 length)
 {
     d->m_cppEngine->fetchMemory(mva, obj, addr, length);
 }
 
-void QmlCppEngine::fetchDisassembler(Internal::DisassemblerViewAgent *dva)
+void QmlCppEngine::fetchDisassembler(DisassemblerViewAgent *dva)
 {
     d->m_cppEngine->fetchDisassembler(dva);
 }
@@ -253,9 +253,10 @@ void QmlCppEngine::selectThread(int index)
     d->m_cppEngine->selectThread(index);
 }
 
-void QmlCppEngine::assignValueInDebugger(const Internal::WatchData *w, const QString &expr, const QVariant &value)
+void QmlCppEngine::assignValueInDebugger(const WatchData *data,
+    const QString &expr, const QVariant &value)
 {
-    d->m_activeEngine->assignValueInDebugger(w, expr, value);
+    d->m_activeEngine->assignValueInDebugger(data, expr, value);
 }
 
 QAbstractItemModel *QmlCppEngine::modulesModel() const