Commit af6bbc44 authored by Friedemann Kleint's avatar Friedemann Kleint

Add debugger engine type to configuration.

Introduce a struct DebuggerItem as a debugger configuration
item, containing debugger engine type and binary. Store
information as a variant map. Add a combo box.

Remove engine guessing logic. Parts of it are still required
when checking the suggested debugger from the SDK.

Split error checking to be able to do a quick error check
and find only valid profiles in the matchers.

Pass on errors up to RunControl::create().

Change-Id: I08653e2a76ca2c371701082f8173b0b8f8ed462e
Reviewed-by: default avatarTobias Hunger <tobias.hunger@nokia.com>
parent 824d0425
......@@ -374,8 +374,7 @@ bool StartApplicationDialog::run(QWidget *parent, QSettings *settings, DebuggerS
}
Kit *kit = dialog.d->kitChooser->currentKit();
QTC_ASSERT(kit, return false);
fillParameters(sp, kit);
QTC_ASSERT(kit && fillParameters(sp, kit), return false);
sp->executable = newParameters.localExecutable;
sp->displayName = newParameters.displayName();
......
......@@ -29,7 +29,6 @@
**************************************************************************/
#include "debuggerkitconfigwidget.h"
#include "debuggerkitinformation.h"
#include <projectexplorer/abi.h>
......@@ -48,6 +47,8 @@
#include <QHBoxLayout>
#include <QPushButton>
#include <QVBoxLayout>
#include <QLabel>
#include <QComboBox>
namespace Debugger {
namespace Internal {
......@@ -55,6 +56,7 @@ namespace Internal {
static const char dgbToolsDownloadLink32C[] = "http://www.microsoft.com/whdc/devtools/debugging/installx86.Mspx";
static const char dgbToolsDownloadLink64C[] = "http://www.microsoft.com/whdc/devtools/debugging/install64bit.Mspx";
// -----------------------------------------------------------------------
// DebuggerKitConfigWidget:
// -----------------------------------------------------------------------
......@@ -65,34 +67,26 @@ DebuggerKitConfigWidget::DebuggerKitConfigWidget(ProjectExplorer::Kit *k,
ProjectExplorer::KitConfigWidget(parent),
m_kit(k),
m_info(ki),
m_chooser(new Utils::PathChooser)
m_comboBox(new QComboBox(this)),
m_label(new QLabel(this)),
m_chooser(new Utils::PathChooser(this))
{
setToolTip(tr("The debugger to use for this kit."));
QVBoxLayout *layout = new QVBoxLayout(this);
layout->setMargin(0);
ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(k);
if (tc && tc->targetAbi().os() == ProjectExplorer::Abi::WindowsOS
&& tc->targetAbi().osFlavor() != ProjectExplorer::Abi::WindowsMSysFlavor) {
QLabel *msvcDebuggerConfigLabel = new QLabel;
#ifdef Q_OS_WIN
const bool is64bit = Utils::winIs64BitSystem();
#else
const bool is64bit = false;
#endif
const QString link = is64bit ? QLatin1String(dgbToolsDownloadLink64C) : QLatin1String(dgbToolsDownloadLink32C);
//: Label text for path configuration. %2 is "x-bit version".
msvcDebuggerConfigLabel->setText(tr("<html><body><p>Specify the path to the "
"<a href=\"%1\">Windows Console Debugger executable</a>"
" (%2) here.</p>"
"</body></html>").arg(link, (is64bit ? tr("64-bit version")
: tr("32-bit version"))));
msvcDebuggerConfigLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
msvcDebuggerConfigLabel->setOpenExternalLinks(true);
layout->addWidget(msvcDebuggerConfigLabel);
m_comboBox->addItem(DebuggerKitInformation::debuggerEngineName(GdbEngineType), QVariant(int(GdbEngineType)));
if (ProjectExplorer::Abi::hostAbi().os() == ProjectExplorer::Abi::WindowsOS) {
m_comboBox->addItem(DebuggerKitInformation::debuggerEngineName(CdbEngineType), QVariant(int(CdbEngineType)));
} else {
m_comboBox->addItem(DebuggerKitInformation::debuggerEngineName(LldbEngineType), QVariant(int(LldbEngineType)));
}
layout->addWidget(m_comboBox);
m_label->setTextInteractionFlags(Qt::TextBrowserInteraction);
m_label->setOpenExternalLinks(true);
layout->addWidget(m_label);
m_chooser->setContentsMargins(0, 0, 0, 0);
m_chooser->setExpectedKind(Utils::PathChooser::ExistingCommand);
......@@ -102,6 +96,8 @@ DebuggerKitConfigWidget::DebuggerKitConfigWidget(ProjectExplorer::Kit *k,
discard();
connect(m_chooser, SIGNAL(changed(QString)), this, SIGNAL(dirty()));
connect(m_comboBox, SIGNAL(currentIndexChanged(int)), this, SIGNAL(dirty()));
connect(m_comboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(refreshLabel()));
}
QString DebuggerKitConfigWidget::displayName() const
......@@ -111,23 +107,26 @@ QString DebuggerKitConfigWidget::displayName() const
void DebuggerKitConfigWidget::makeReadOnly()
{
m_comboBox->setEnabled(false);
m_chooser->setEnabled(false);
}
void DebuggerKitConfigWidget::apply()
{
Utils::FileName fn = m_chooser->fileName();
DebuggerKitInformation::setDebuggerCommand(m_kit, fn);
DebuggerKitInformation::setDebuggerItem(m_kit, DebuggerKitInformation::DebuggerItem(engineType(), fileName()));
}
void DebuggerKitConfigWidget::discard()
{
m_chooser->setFileName(DebuggerKitInformation::debuggerCommand(m_kit));
const DebuggerKitInformation::DebuggerItem item = DebuggerKitInformation::debuggerItem(m_kit);
setEngineType(item.engineType);
setFileName(item.binary);
}
bool DebuggerKitConfigWidget::isDirty() const
{
return m_chooser->fileName() != DebuggerKitInformation::debuggerCommand(m_kit);
const DebuggerKitInformation::DebuggerItem item = DebuggerKitInformation::debuggerItem(m_kit);
return item.engineType != engineType() || item.binary != fileName();
}
QWidget *DebuggerKitConfigWidget::buttonWidget() const
......@@ -137,8 +136,62 @@ QWidget *DebuggerKitConfigWidget::buttonWidget() const
void DebuggerKitConfigWidget::autoDetectDebugger()
{
QVariant v = m_info->defaultValue(m_kit);
m_chooser->setFileName(Utils::FileName::fromString(v.toString()));
const DebuggerKitInformation::DebuggerItem item = DebuggerKitInformation::autoDetectItem(m_kit);
setEngineType(item.engineType);
setFileName(item.binary);
}
DebuggerEngineType DebuggerKitConfigWidget::engineType() const
{
const int index = m_comboBox->currentIndex();
return static_cast<DebuggerEngineType>(m_comboBox->itemData(index).toInt());
}
void DebuggerKitConfigWidget::setEngineType(DebuggerEngineType et)
{
const int size = m_comboBox->count();
for (int i = 0; i < size; ++i) {
if (m_comboBox->itemData(i).toInt() == et) {
m_comboBox->setCurrentIndex(i);
refreshLabel();
break;
}
}
}
Utils::FileName DebuggerKitConfigWidget::fileName() const
{
return m_chooser->fileName();
}
void DebuggerKitConfigWidget::setFileName(const Utils::FileName &fn)
{
m_chooser->setFileName(fn);
}
void DebuggerKitConfigWidget::refreshLabel()
{
QString text;
switch (engineType()) {
case CdbEngineType: {
#ifdef Q_OS_WIN
const bool is64bit = Utils::winIs64BitSystem();
#else
const bool is64bit = false;
#endif
const QString link = is64bit ? QLatin1String(dgbToolsDownloadLink64C) : QLatin1String(dgbToolsDownloadLink32C);
const QString versionString = is64bit ? tr("64-bit version") : tr("32-bit version");
//: Label text for path configuration. %2 is "x-bit version".
text = tr("<html><body><p>Specify the path to the "
"<a href=\"%1\">Windows Console Debugger executable</a>"
" (%2) here.</p>""</body></html>").arg(link, versionString);
}
break;
default:
break;
}
m_label->setText(text);
m_label->setVisible(!text.isEmpty());
}
} // namespace Internal
......
......@@ -33,11 +33,16 @@
#include <projectexplorer/kitconfigwidget.h>
#include <QLabel>
#include <debuggerkitinformation.h>
#include "debuggerconstants.h"
QT_FORWARD_DECLARE_CLASS(QLabel)
QT_FORWARD_DECLARE_CLASS(QComboBox)
namespace ProjectExplorer { class Kit; }
namespace Utils { class PathChooser; }
namespace Utils {
class PathChooser;
class FileName;
}
namespace Debugger {
class DebuggerKitInformation;
......@@ -65,12 +70,21 @@ public:
bool isDirty() const;
QWidget *buttonWidget() const;
DebuggerEngineType engineType() const;
void setEngineType(DebuggerEngineType et);
Utils::FileName fileName() const;
void setFileName(const Utils::FileName &fn);
private slots:
void autoDetectDebugger();
void refreshLabel();
private:
ProjectExplorer::Kit *m_kit;
const DebuggerKitInformation *m_info;
QComboBox *m_comboBox;
QLabel *m_label;
Utils::PathChooser *m_chooser;
};
......
......@@ -32,6 +32,7 @@
#define DEBUGGER_DEBUGGERKITINFORMATION_H
#include "debugger_global.h"
#include "debuggerconstants.h"
#include <projectexplorer/kitinformation.h>
......@@ -42,22 +43,54 @@ class DEBUGGER_EXPORT DebuggerKitInformation : public ProjectExplorer::KitInform
Q_OBJECT
public:
class DEBUGGER_EXPORT DebuggerItem {
public:
DebuggerItem();
DebuggerItem(DebuggerEngineType engineType, const Utils::FileName &fn);
DebuggerEngineType engineType;
Utils::FileName binary;
};
DebuggerKitInformation();
Core::Id dataId() const;
unsigned int priority() const; // the higher the closer to the top.
QVariant defaultValue(ProjectExplorer::Kit *k) const;
static DebuggerItem autoDetectItem(const ProjectExplorer::Kit *k);
QVariant defaultValue(ProjectExplorer::Kit *k) const
{ return DebuggerKitInformation::itemToVariant(DebuggerKitInformation::autoDetectItem(k)); }
QList<ProjectExplorer::Task> validate(ProjectExplorer::Kit *k) const
{ return DebuggerKitInformation::validateDebugger(k); }
QList<ProjectExplorer::Task> validate(ProjectExplorer::Kit *k) const;
static QList<ProjectExplorer::Task> validateDebugger(const ProjectExplorer::Kit *p);
static bool isValidDebugger(const ProjectExplorer::Kit *p);
ProjectExplorer::KitConfigWidget *createConfigWidget(ProjectExplorer::Kit *k) const;
ItemList toUserOutput(ProjectExplorer::Kit *k) const;
static QString userOutput(const ProjectExplorer::Kit *k);
static DebuggerItem debuggerItem(const ProjectExplorer::Kit *p);
static void setDebuggerItem(ProjectExplorer::Kit *p, const DebuggerItem &item);
static Utils::FileName debuggerCommand(const ProjectExplorer::Kit *p)
{ return debuggerItem(p).binary; }
static void setDebuggerCommand(ProjectExplorer::Kit *p, const Utils::FileName &command);
static DebuggerEngineType engineType(const ProjectExplorer::Kit *p)
{ return debuggerItem(p).engineType; }
static void setEngineType(ProjectExplorer::Kit *p, DebuggerEngineType type);
static QString debuggerEngineName(DebuggerEngineType t);
static Utils::FileName debuggerCommand(const ProjectExplorer::Kit *k);
static void setDebuggerCommand(ProjectExplorer::Kit *k, const Utils::FileName &command);
private:
static DebuggerItem variantToItem(const QVariant &v);
static QVariant itemToVariant(const DebuggerItem &i);
};
} // namespace Debugger
......
......@@ -567,8 +567,10 @@ public:
explicit AbiKitMatcher(const QList<Abi> &abis) : m_abis(abis) {}
bool matches(const Kit *p) const
{
if (const ToolChain *tc = ToolChainKitInformation::toolChain(p))
return m_abis.contains(tc->targetAbi());
if (const ToolChain *tc = ToolChainKitInformation::toolChain(p)) {
return m_abis.contains(tc->targetAbi())
&& DebuggerKitInformation::isValidDebugger(p);
}
return false;
}
......@@ -584,7 +586,7 @@ public:
{
if (const ToolChain *tc = ToolChainKitInformation::toolChain(p))
foreach (const Abi &a, m_abis)
if (a.isCompatibleWith(tc->targetAbi()))
if (a.isCompatibleWith(tc->targetAbi()) && DebuggerKitInformation::isValidDebugger(p))
return true;
return false;
}
......@@ -600,18 +602,14 @@ public:
bool matches(const Kit *k) const
{
const ToolChain *tc = ToolChainKitInformation::toolChain(k);
QTC_ASSERT(tc, return false);
const Abi abi = tc->targetAbi();
if (abi.architecture() != Abi::X86Architecture
|| abi.os() != Abi::WindowsOS
|| abi.binaryFormat() != Abi::PEFormat)
return false;
if (abi.osFlavor() == Abi::WindowsMSysFlavor
|| abi.osFlavor() == Abi::WindowsCEFlavor)
return false;
if (m_wordWidth && abi.wordWidth() != m_wordWidth)
if (DebuggerKitInformation::engineType(k) != CdbEngineType
|| !DebuggerKitInformation::isValidDebugger(k)) {
return false;
}
if (m_wordWidth) {
const ToolChain *tc = ToolChainKitInformation::toolChain(k);
return tc && m_wordWidth == tc->targetAbi().wordWidth();
}
return true;
}
......@@ -634,7 +632,7 @@ private:
const char m_wordWidth;
};
void fillParameters(DebuggerStartParameters *sp, const Kit *kit /* = 0 */)
bool fillParameters(DebuggerStartParameters *sp, const Kit *kit /* = 0 */, QString *errorMessage /* = 0 */)
{
if (!kit) {
// This code can only be reached when starting via the command line
......@@ -664,6 +662,27 @@ void fillParameters(DebuggerStartParameters *sp, const Kit *kit /* = 0 */)
kit = KitManager::instance()->defaultKit();
}
// Verify that debugger and profile are valid
if (!kit) {
sp->startMode = NoStartMode;
if (errorMessage)
*errorMessage = DebuggerKitInformation::tr("No kit found.");
return false;
}
const QList<ProjectExplorer::Task> tasks = DebuggerKitInformation::validateDebugger(kit);
if (!tasks.isEmpty()) {
sp->startMode = NoStartMode;
if (errorMessage) {
foreach (const ProjectExplorer::Task &t, tasks) {
if (errorMessage->isEmpty())
errorMessage->append(QLatin1Char('\n'));
errorMessage->append(t.description);
}
}
return false;
}
sp->cppEngineType = DebuggerKitInformation::engineType(kit);
sp->sysRoot = SysRootKitInformation::sysRoot(kit).toString();
sp->debuggerCommand = DebuggerKitInformation::debuggerCommand(kit).toString();
......@@ -676,6 +695,7 @@ void fillParameters(DebuggerStartParameters *sp, const Kit *kit /* = 0 */)
sp->connParams = device->sshParameters();
sp->remoteChannel = sp->connParams.host + QLatin1Char(':') + QString::number(sp->connParams.port);
}
return true;
}
static TextEditor::ITextEditor *currentTextEditor()
......@@ -1438,7 +1458,8 @@ bool DebuggerPluginPrivate::parseArgument(QStringList::const_iterator &it,
}
}
}
fillParameters(&sp, kit);
if (fillParameters(&sp, kit, errorMessage))
return false;
if (sp.startMode == StartExternal) {
sp.displayName = tr("Executable file \"%1\"").arg(sp.executable);
sp.startMessage = tr("Debugging file %1.").arg(sp.executable);
......@@ -1458,7 +1479,8 @@ bool DebuggerPluginPrivate::parseArgument(QStringList::const_iterator &it,
return false;
}
DebuggerStartParameters sp;
fillParameters(&sp, CdbMatcher::findUniversalCdbKit());
if (!fillParameters(&sp, CdbMatcher::findUniversalCdbKit(), errorMessage))
return false;
sp.startMode = AttachCrashedExternal;
sp.crashParameter = it->section(QLatin1Char(':'), 0, 0);
sp.attachPID = it->section(QLatin1Char(':'), 1, 1).toULongLong();
......@@ -1596,7 +1618,7 @@ void DebuggerPluginPrivate::attachCore()
DebuggerStartParameters sp;
QString display = dlg.isLocal() ? dlg.localCoreFile() : dlg.remoteCoreFile();
fillParameters(&sp, dlg.kit());
QTC_ASSERT(fillParameters(&sp, dlg.kit()), return);
sp.masterEngineType = GdbEngineType;
sp.executable = dlg.localExecutableFile();
sp.coreFile = dlg.localCoreFile();
......@@ -1612,8 +1634,7 @@ void DebuggerPluginPrivate::startRemoteCdbSession()
const QString connectionKey = _("CdbRemoteConnection");
DebuggerStartParameters sp;
Kit *kit = CdbMatcher::findUniversalCdbKit();
QTC_ASSERT(kit, return);
fillParameters(&sp, kit);
QTC_ASSERT(kit && fillParameters(&sp, kit), return);
sp.startMode = AttachToRemoteServer;
sp.closeMode = KillAtClose;
StartRemoteCdbDialog dlg(mainWindow());
......@@ -1683,7 +1704,7 @@ void DebuggerPluginPrivate::attachToProcess(bool startServerOnly)
if (device->type() == ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE) {
DebuggerStartParameters sp;
fillParameters(&sp, kit);
QTC_ASSERT(fillParameters(&sp, kit), return);
sp.attachPID = process.pid;
sp.displayName = tr("Process %1").arg(process.pid);
sp.executable = process.exe;
......@@ -1708,7 +1729,7 @@ void DebuggerPluginPrivate::attachExternalApplication(ProjectExplorer::RunContro
if (const RunConfiguration *runConfiguration = rc->runConfiguration())
if (const Target *target = runConfiguration->target())
kit = target->kit();
fillParameters(&sp, kit);
QTC_ASSERT(fillParameters(&sp, kit), return);
DebuggerRunControlFactory::createAndScheduleRun(sp);
}
......@@ -1731,11 +1752,10 @@ void DebuggerPluginPrivate::attachToQmlPort()
return;
Kit *kit = dlg.kit();
QTC_ASSERT(kit, return);
QTC_ASSERT(kit && fillParameters(&sp, kit), return);
setConfigValue(_("LastQmlServerPort"), dlg.port());
setConfigValue(_("LastProfile"), kit->id().toString());
fillParameters(&sp, kit);
sp.qmlServerAddress = sp.connParams.host;
sp.qmlServerPort = dlg.port();
sp.startMode = AttachToRemoteProcess;
......
......@@ -259,11 +259,6 @@ public:
explicit DebuggerRunControlPrivate(DebuggerRunControl *parent,
RunConfiguration *runConfiguration);
DebuggerEngineType engineForExecutable(unsigned enabledEngineTypes,
const QString &executable);
DebuggerEngineType engineForMode(unsigned enabledEngineTypes,
DebuggerStartMode mode);
public:
DebuggerRunControl *q;
DebuggerEngine *m_engine;
......@@ -476,7 +471,7 @@ QString DebuggerRunControlFactory::displayName() const
return DebuggerPlugin::tr("Debug");
}
static DebuggerStartParameters localStartParameters(RunConfiguration *runConfiguration)
static DebuggerStartParameters localStartParameters(RunConfiguration *runConfiguration, QString *errorMessage)
{
DebuggerStartParameters sp;
QTC_ASSERT(runConfiguration, return sp);
......@@ -486,7 +481,8 @@ static DebuggerStartParameters localStartParameters(RunConfiguration *runConfigu
Target *target = runConfiguration->target();
Kit *kit = target ? target->kit() : KitManager::instance()->defaultKit();
fillParameters(&sp, kit);
if (!fillParameters(&sp, kit, errorMessage))
return sp;
sp.environment = rc->environment();
sp.workingDirectory = rc->workingDirectory();
......@@ -547,7 +543,7 @@ RunControl *DebuggerRunControlFactory::create
{
Q_UNUSED(errorMessage)
QTC_ASSERT(mode == DebugRunMode || mode == DebugRunModeWithBreakOnMain, return 0);
DebuggerStartParameters sp = localStartParameters(runConfiguration);
DebuggerStartParameters sp = localStartParameters(runConfiguration, errorMessage);
if (sp.startMode == NoStartMode)
return 0;
if (mode == DebugRunModeWithBreakOnMain)
......@@ -556,92 +552,43 @@ RunControl *DebuggerRunControlFactory::create
return doCreate(sp, runConfiguration, errorMessage);
}
static DebuggerEngineType guessUnixCppEngineType(const DebuggerStartParameters &sp)
{
if (sp.debuggerCommand.contains(QLatin1String("lldb")))
return LldbEngineType;
return GdbEngineType;
}
static DebuggerEngineType guessCppEngineTypeForAbi(const DebuggerStartParameters &sp, const Abi &abi)
{
switch (abi.binaryFormat()) {
case Abi::ElfFormat:
case Abi::MachOFormat:
return guessUnixCppEngineType(sp) ;
case Abi::PEFormat:
if (abi.osFlavor() == Abi::WindowsMSysFlavor)
return guessUnixCppEngineType(sp);
return CdbEngineType;
default:
break;
}
return NoEngineType;
}
static DebuggerEngineType guessCppEngineType(const DebuggerStartParameters &sp)
{
if (sp.toolChainAbi.isValid()) {
const DebuggerEngineType et = guessCppEngineTypeForAbi(sp, sp.toolChainAbi);
if (et != NoEngineType)
return et;
}
#ifdef Q_OS_WIN
// If a file has PDB files, it has been compiled by VS.
if (sp.executable.endsWith(_(".exe"), Qt::CaseInsensitive)) {
QStringList pdbFiles;
QString errorMessage;
if (getPDBFiles(sp.executable, &pdbFiles, &errorMessage) && !pdbFiles.isEmpty())
return CdbEngineType;
}
#endif
QList<Abi> abis = Abi::abisOfBinary(FileName::fromString(sp.executable));
foreach (const Abi &abi, abis) {
DebuggerEngineType et = guessCppEngineTypeForAbi(sp, abi);
if (et != NoEngineType)
return et;
}
return guessUnixCppEngineType(sp);
}
static void fixupEngineTypes(DebuggerStartParameters &sp, RunConfiguration *rc)
static bool fixupEngineTypes(DebuggerStartParameters &sp, RunConfiguration *rc, QString *errorMessage)
{
if (sp.masterEngineType != NoEngineType)
return;
return true;
if (sp.executable.endsWith(_(".js"))) {
sp.masterEngineType = ScriptEngineType;
return;
return true;
}
if (sp.executable.endsWith(_(".py"))) {
sp.masterEngineType = PdbEngineType;
return;
return true;
}
if (rc) {
DebuggerRunConfigurationAspect *aspect = rc->debuggerAspect();
if (const Target *target = rc->target())
fillParameters(&sp, target->kit());
if (!fillParameters(&sp, target->kit(), errorMessage))
return false;
const bool useCppDebugger = aspect->useCppDebugger();
const bool useQmlDebugger = aspect->useQmlDebugger();
if (useQmlDebugger) {
if (useCppDebugger) {
sp.masterEngineType = QmlCppEngineType;
sp.firstSlaveEngineType = guessCppEngineType(sp);
sp.firstSlaveEngineType = sp.cppEngineType;
sp.secondSlaveEngineType = QmlCppEngineType;
} else {
sp.masterEngineType = QmlEngineType;
}
} else {
sp.masterEngineType = guessCppEngineType(sp);
sp.masterEngineType = sp.cppEngineType;
}
return;
return true;
}
sp.masterEngineType = guessCppEngineType(sp);
sp.masterEngineType = sp.cppEngineType;
return true;
}
DebuggerRunControl *DebuggerRunControlFactory::doCreate
......@@ -664,10 +611,8 @@ DebuggerRunControl *DebuggerRunControlFactory::doCreate
}
}
fixupEngineTypes(sp, rc);
if (!sp.masterEngineType) {
if (!fixupEngineTypes(sp, rc, errorMessage))
return 0;
}
return new DebuggerRunControl(rc, sp);
}
......
......@@ -60,6 +60,7 @@ public:
: masterEngineType(NoEngineType),
firstSlaveEngineType(NoEngineType),
secondSlaveEngineType(NoEngineType),
cppEngineType(NoEngineType),
isSnapshot(false),
attachPID(-1),
useTerminal(false),
......@@ -81,6 +82,7 @@ public:
DebuggerEngineType masterEngineType;
DebuggerEngineType firstSlaveEngineType;
DebuggerEngineType secondSlaveEngineType;