feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

ProjectExplorer: Some more Toolchain renamings

Browse Source 
Change-Id: If8bdfd5e49a031a511bc0e062727495a12d2d3bd
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
This commit is contained in:
hjk
2023-12-13 14:00:37 +01:00
parent d6b27f372b
commit d2ca6afb8f
19 changed files with 138 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/plugins/baremetal/baremetalplugin.cpp
View File

@@ -28,9 +28,9 @@ class BareMetalPlugin final : public ExtensionSystem::IPlugin
{ {
setupBareMetalDevice(); setupBareMetalDevice();
setupIarToolChain(); setupIarToolchain();
setupKeilToolChain(); setupKeilToolchain();
setupSdccToolChain(); setupSdccToolchain();
setupBareMetalDeployAndRunConfigurations(); setupBareMetalDeployAndRunConfigurations();
setupBareMetalDebugSupport(); setupBareMetalDebugSupport();

68
src/plugins/baremetal/iarewtoolchain.cpp
View File

@@ -253,14 +253,14 @@ static QString buildDisplayName(Abi::Architecture arch, Utils::Id language,
return Tr::tr("IAREW %1 (%2, %3)").arg(version, langName, archName); return Tr::tr("IAREW %1 (%2, %3)").arg(version, langName, archName);
} }
// IarToolChainConfigWidget // IarToolchainConfigWidget
class IarToolChain; class IarToolchain;
class IarToolChainConfigWidget final : public ToolchainConfigWidget class IarToolchainConfigWidget final : public ToolchainConfigWidget
{ {
public: public:
explicit IarToolChainConfigWidget(IarToolChain *tc); explicit IarToolchainConfigWidget(IarToolchain *tc);
private: private:
void applyImpl() final; void applyImpl() final;
@@ -280,10 +280,10 @@ private:
// IarToolChain // IarToolChain
class IarToolChain final : public Toolchain class IarToolchain final : public Toolchain
{ {
public: public:
IarToolChain() : Toolchain(Constants::IAREW_TOOLCHAIN_TYPEID) IarToolchain() : Toolchain(Constants::IAREW_TOOLCHAIN_TYPEID)
{ {
setTypeDisplayName(Tr::tr("IAREW")); setTypeDisplayName(Tr::tr("IAREW"));
setTargetAbiKey("TargetAbi"); setTargetAbiKey("TargetAbi");
@@ -291,7 +291,7 @@ public:
m_extraCodeModelFlags.setSettingsKey("PlatformCodeGenFlags"); m_extraCodeModelFlags.setSettingsKey("PlatformCodeGenFlags");
connect(&m_extraCodeModelFlags, &BaseAspect::changed, connect(&m_extraCodeModelFlags, &BaseAspect::changed,
this, &IarToolChain::toolChainUpdated); this, &IarToolchain::toolChainUpdated);
} }
MacroInspectionRunner createMacroInspectionRunner() const final; MacroInspectionRunner createMacroInspectionRunner() const final;
@@ -315,10 +315,10 @@ private:
StringListAspect m_extraCodeModelFlags{this}; StringListAspect m_extraCodeModelFlags{this};
friend class IarToolchainFactory; friend class IarToolchainFactory;
friend class IarToolChainConfigWidget; friend class IarToolchainConfigWidget;
}; };
Toolchain::MacroInspectionRunner IarToolChain::createMacroInspectionRunner() const Toolchain::MacroInspectionRunner IarToolchain::createMacroInspectionRunner() const
{ {
Environment env = Environment::systemEnvironment(); Environment env = Environment::systemEnvironment();
addToEnvironment(env); addToEnvironment(env);
@@ -348,18 +348,18 @@ Toolchain::MacroInspectionRunner IarToolChain::createMacroInspectionRunner() con
}; };
} }
Utils::LanguageExtensions IarToolChain::languageExtensions(const QStringList &) const Utils::LanguageExtensions IarToolchain::languageExtensions(const QStringList &) const
{ {
return LanguageExtension::None; return LanguageExtension::None;
} }
WarningFlags IarToolChain::warningFlags(const QStringList &cxxflags) const WarningFlags IarToolchain::warningFlags(const QStringList &cxxflags) const
{ {
Q_UNUSED(cxxflags) Q_UNUSED(cxxflags)
return WarningFlags::Default; return WarningFlags::Default;
} }
Toolchain::BuiltInHeaderPathsRunner IarToolChain::createBuiltInHeaderPathsRunner( Toolchain::BuiltInHeaderPathsRunner IarToolchain::createBuiltInHeaderPathsRunner(
const Environment &) const const Environment &) const
{ {
Environment env = Environment::systemEnvironment(); Environment env = Environment::systemEnvironment();
@@ -383,23 +383,23 @@ Toolchain::BuiltInHeaderPathsRunner IarToolChain::createBuiltInHeaderPathsRunner
}; };
} }
void IarToolChain::addToEnvironment(Environment &env) const void IarToolchain::addToEnvironment(Environment &env) const
{ {
if (!compilerCommand().isEmpty()) if (!compilerCommand().isEmpty())
env.prependOrSetPath(compilerCommand().parentDir()); env.prependOrSetPath(compilerCommand().parentDir());
} }
std::unique_ptr<ToolchainConfigWidget> IarToolChain::createConfigurationWidget() std::unique_ptr<ToolchainConfigWidget> IarToolchain::createConfigurationWidget()
{ {
return std::make_unique<IarToolChainConfigWidget>(this); return std::make_unique<IarToolchainConfigWidget>(this);
} }
bool IarToolChain::operator==(const Toolchain &other) const bool IarToolchain::operator==(const Toolchain &other) const
{ {
if (!Toolchain::operator==(other)) if (!Toolchain::operator==(other))
return false; return false;
const auto customTc = static_cast<const IarToolChain *>(&other); const auto customTc = static_cast<const IarToolchain *>(&other);
return compilerCommand() == customTc->compilerCommand() return compilerCommand() == customTc->compilerCommand()
&& m_extraCodeModelFlags() == customTc->m_extraCodeModelFlags(); && m_extraCodeModelFlags() == customTc->m_extraCodeModelFlags();
} }
@@ -416,7 +416,7 @@ public:
setSupportedToolchainType(Constants::IAREW_TOOLCHAIN_TYPEID); setSupportedToolchainType(Constants::IAREW_TOOLCHAIN_TYPEID);
setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID, setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID,
ProjectExplorer::Constants::CXX_LANGUAGE_ID}); ProjectExplorer::Constants::CXX_LANGUAGE_ID});
setToolchainConstructor([] { return new IarToolChain; }); setToolchainConstructor([] { return new IarToolchain; });
setUserCreatable(true); setUserCreatable(true);
} }
@@ -429,9 +429,9 @@ private:
Toolchains autoDetectToolchain(const Candidate &candidate, Id languageId) const; Toolchains autoDetectToolchain(const Candidate &candidate, Id languageId) const;
}; };
void setupIarToolChain() void setupIarToolchain()
{ {
static IarToolchainFactory theIarToolChainFactory; static IarToolchainFactory theIarToolchainFactory;
} }
Toolchains IarToolchainFactory::autoDetect(const ToolchainDetector &detector) const Toolchains IarToolchainFactory::autoDetect(const ToolchainDetector &detector) const
@@ -550,7 +550,7 @@ Toolchains IarToolchainFactory::autoDetectToolchain(const Candidate &candidate,
} }
const Abi abi = guessAbi(macros); const Abi abi = guessAbi(macros);
const auto tc = new IarToolChain; const auto tc = new IarToolchain;
tc->setDetection(Toolchain::AutoDetection); tc->setDetection(Toolchain::AutoDetection);
tc->setLanguage(languageId); tc->setLanguage(languageId);
tc->setCompilerCommand(candidate.compilerPath); tc->setCompilerCommand(candidate.compilerPath);
@@ -563,9 +563,9 @@ Toolchains IarToolchainFactory::autoDetectToolchain(const Candidate &candidate,
return {tc}; return {tc};
} }
// IarToolChainConfigWidget // IarToolchainConfigWidget
IarToolChainConfigWidget::IarToolChainConfigWidget(IarToolChain *tc) : IarToolchainConfigWidget::IarToolchainConfigWidget(IarToolchain *tc) :
ToolchainConfigWidget(tc), ToolchainConfigWidget(tc),
m_compilerCommand(new PathChooser), m_compilerCommand(new PathChooser),
m_abiWidget(new AbiWidget) m_abiWidget(new AbiWidget)
@@ -584,19 +584,19 @@ IarToolChainConfigWidget::IarToolChainConfigWidget(IarToolChain *tc) :
setFromToolchain(); setFromToolchain();
connect(m_compilerCommand, &PathChooser::rawPathChanged, connect(m_compilerCommand, &PathChooser::rawPathChanged,
this, &IarToolChainConfigWidget::handleCompilerCommandChange); this, &IarToolchainConfigWidget::handleCompilerCommandChange);
connect(m_platformCodeGenFlagsLineEdit, &QLineEdit::editingFinished, connect(m_platformCodeGenFlagsLineEdit, &QLineEdit::editingFinished,
this, &IarToolChainConfigWidget::handlePlatformCodeGenFlagsChange); this, &IarToolchainConfigWidget::handlePlatformCodeGenFlagsChange);
connect(m_abiWidget, &AbiWidget::abiChanged, connect(m_abiWidget, &AbiWidget::abiChanged,
this, &ToolchainConfigWidget::dirty); this, &ToolchainConfigWidget::dirty);
} }
void IarToolChainConfigWidget::applyImpl() void IarToolchainConfigWidget::applyImpl()
{ {
if (toolChain()->isAutoDetected()) if (toolChain()->isAutoDetected())
return; return;
const auto tc = static_cast<IarToolChain *>(toolChain()); const auto tc = static_cast<IarToolchain *>(toolChain());
const QString displayName = tc->displayName(); const QString displayName = tc->displayName();
tc->setCompilerCommand(m_compilerCommand->filePath()); tc->setCompilerCommand(m_compilerCommand->filePath());
@@ -614,26 +614,26 @@ void IarToolChainConfigWidget::applyImpl()
setFromToolchain(); setFromToolchain();
} }
bool IarToolChainConfigWidget::isDirtyImpl() const bool IarToolchainConfigWidget::isDirtyImpl() const
{ {
const auto tc = static_cast<IarToolChain *>(toolChain()); const auto tc = static_cast<IarToolchain *>(toolChain());
return m_compilerCommand->filePath() != tc->compilerCommand() return m_compilerCommand->filePath() != tc->compilerCommand()
|| m_platformCodeGenFlagsLineEdit->text() != ProcessArgs::joinArgs(tc->extraCodeModelFlags()) || m_platformCodeGenFlagsLineEdit->text() != ProcessArgs::joinArgs(tc->extraCodeModelFlags())
|| m_abiWidget->currentAbi() != tc->targetAbi() || m_abiWidget->currentAbi() != tc->targetAbi()
; ;
} }
void IarToolChainConfigWidget::makeReadOnlyImpl() void IarToolchainConfigWidget::makeReadOnlyImpl()
{ {
m_compilerCommand->setReadOnly(true); m_compilerCommand->setReadOnly(true);
m_platformCodeGenFlagsLineEdit->setEnabled(false); m_platformCodeGenFlagsLineEdit->setEnabled(false);
m_abiWidget->setEnabled(false); m_abiWidget->setEnabled(false);
} }
void IarToolChainConfigWidget::setFromToolchain() void IarToolchainConfigWidget::setFromToolchain()
{ {
const QSignalBlocker blocker(this); const QSignalBlocker blocker(this);
const auto tc = static_cast<IarToolChain *>(toolChain()); const auto tc = static_cast<IarToolchain *>(toolChain());
m_compilerCommand->setFilePath(tc->compilerCommand()); m_compilerCommand->setFilePath(tc->compilerCommand());
m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->extraCodeModelFlags())); m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->extraCodeModelFlags()));
m_abiWidget->setAbis({}, tc->targetAbi()); m_abiWidget->setAbis({}, tc->targetAbi());
@@ -641,7 +641,7 @@ void IarToolChainConfigWidget::setFromToolchain()
m_abiWidget->setEnabled(haveCompiler && !tc->isAutoDetected()); m_abiWidget->setEnabled(haveCompiler && !tc->isAutoDetected());
} }
void IarToolChainConfigWidget::handleCompilerCommandChange() void IarToolchainConfigWidget::handleCompilerCommandChange()
{ {
const FilePath compilerPath = m_compilerCommand->filePath(); const FilePath compilerPath = m_compilerCommand->filePath();
const bool haveCompiler = compilerPath.isExecutableFile(); const bool haveCompiler = compilerPath.isExecutableFile();
@@ -658,7 +658,7 @@ void IarToolChainConfigWidget::handleCompilerCommandChange()
emit dirty(); emit dirty();
} }
void IarToolChainConfigWidget::handlePlatformCodeGenFlagsChange() void IarToolchainConfigWidget::handlePlatformCodeGenFlagsChange()
{ {
const QString str1 = m_platformCodeGenFlagsLineEdit->text(); const QString str1 = m_platformCodeGenFlagsLineEdit->text();
const QString str2 = ProcessArgs::joinArgs(splitString(str1)); const QString str2 = ProcessArgs::joinArgs(splitString(str1));

2
src/plugins/baremetal/iarewtoolchain.h
View File

@@ -5,6 +5,6 @@
namespace BareMetal::Internal { namespace BareMetal::Internal {
void setupIarToolChain(); void setupIarToolchain();
} // BareMetal::Internal } // BareMetal::Internal

76
src/plugins/baremetal/keiltoolchain.cpp
View File

@@ -393,20 +393,20 @@ static void addDefaultCpuArgs(const FilePath &compiler, QStringList &extraArgs)
// KeilToolchain // KeilToolchain
class KeilToolChain; class KeilToolchain;
class KeilToolChainConfigWidget final : public ToolchainConfigWidget class KeilToolchainConfigWidget final : public ToolchainConfigWidget
{ {
public: public:
explicit KeilToolChainConfigWidget(KeilToolChain *tc); explicit KeilToolchainConfigWidget(KeilToolchain *tc);
private: private:
void applyImpl() final; void applyImpl() final;
void discardImpl() final { setFromToolChain(); } void discardImpl() final { setFromToolchain(); }
bool isDirtyImpl() const final; bool isDirtyImpl() const final;
void makeReadOnlyImpl() final; void makeReadOnlyImpl() final;
void setFromToolChain(); void setFromToolchain();
void handleCompilerCommandChange(); void handleCompilerCommandChange();
void handlePlatformCodeGenFlagsChange(); void handlePlatformCodeGenFlagsChange();
@@ -416,12 +416,12 @@ private:
Macros m_macros; Macros m_macros;
}; };
// KeilToolChain // KeilToolchain
class KeilToolChain final : public Toolchain class KeilToolchain final : public Toolchain
{ {
public: public:
KeilToolChain() : KeilToolchain() :
Toolchain(Constants::KEIL_TOOLCHAIN_TYPEID) Toolchain(Constants::KEIL_TOOLCHAIN_TYPEID)
{ {
setTypeDisplayName(Tr::tr("KEIL")); setTypeDisplayName(Tr::tr("KEIL"));
@@ -430,7 +430,7 @@ public:
m_extraCodeModelFlags.setSettingsKey("PlatformCodeGenFlags"); m_extraCodeModelFlags.setSettingsKey("PlatformCodeGenFlags");
connect(&m_extraCodeModelFlags, &BaseAspect::changed, connect(&m_extraCodeModelFlags, &BaseAspect::changed,
this, &KeilToolChain::toolChainUpdated); this, &KeilToolchain::toolChainUpdated);
} }
MacroInspectionRunner createMacroInspectionRunner() const final; MacroInspectionRunner createMacroInspectionRunner() const final;
@@ -455,10 +455,10 @@ private:
StringListAspect m_extraCodeModelFlags{this}; StringListAspect m_extraCodeModelFlags{this};
friend class KeilToolchainFactory; friend class KeilToolchainFactory;
friend class KeilToolChainConfigWidget; friend class KeilToolchainConfigWidget;
}; };
Toolchain::MacroInspectionRunner KeilToolChain::createMacroInspectionRunner() const Toolchain::MacroInspectionRunner KeilToolchain::createMacroInspectionRunner() const
{ {
Environment env = Environment::systemEnvironment(); Environment env = Environment::systemEnvironment();
addToEnvironment(env); addToEnvironment(env);
@@ -480,18 +480,18 @@ Toolchain::MacroInspectionRunner KeilToolChain::createMacroInspectionRunner() co
}; };
} }
Utils::LanguageExtensions KeilToolChain::languageExtensions(const QStringList &) const Utils::LanguageExtensions KeilToolchain::languageExtensions(const QStringList &) const
{ {
return LanguageExtension::None; return LanguageExtension::None;
} }
WarningFlags KeilToolChain::warningFlags(const QStringList &cxxflags) const WarningFlags KeilToolchain::warningFlags(const QStringList &cxxflags) const
{ {
Q_UNUSED(cxxflags) Q_UNUSED(cxxflags)
return WarningFlags::Default; return WarningFlags::Default;
} }
Toolchain::BuiltInHeaderPathsRunner KeilToolChain::createBuiltInHeaderPathsRunner( Toolchain::BuiltInHeaderPathsRunner KeilToolchain::createBuiltInHeaderPathsRunner(
const Environment &) const const Environment &) const
{ {
const FilePath compiler = compilerCommand(); const FilePath compiler = compilerCommand();
@@ -509,29 +509,29 @@ Toolchain::BuiltInHeaderPathsRunner KeilToolChain::createBuiltInHeaderPathsRunne
}; };
} }
void KeilToolChain::addToEnvironment(Environment &env) const void KeilToolchain::addToEnvironment(Environment &env) const
{ {
if (!compilerCommand().isEmpty()) if (!compilerCommand().isEmpty())
env.prependOrSetPath(compilerCommand().parentDir()); env.prependOrSetPath(compilerCommand().parentDir());
} }
std::unique_ptr<ToolchainConfigWidget> KeilToolChain::createConfigurationWidget() std::unique_ptr<ToolchainConfigWidget> KeilToolchain::createConfigurationWidget()
{ {
return std::make_unique<KeilToolChainConfigWidget>(this); return std::make_unique<KeilToolchainConfigWidget>(this);
} }
bool KeilToolChain::operator ==(const Toolchain &other) const bool KeilToolchain::operator ==(const Toolchain &other) const
{ {
if (!Toolchain::operator ==(other)) if (!Toolchain::operator ==(other))
return false; return false;
const auto customTc = static_cast<const KeilToolChain *>(&other); const auto customTc = static_cast<const KeilToolchain *>(&other);
return compilerCommand() == customTc->compilerCommand() return compilerCommand() == customTc->compilerCommand()
&& targetAbi() == customTc->targetAbi() && targetAbi() == customTc->targetAbi()
&& m_extraCodeModelFlags() == customTc->m_extraCodeModelFlags(); && m_extraCodeModelFlags() == customTc->m_extraCodeModelFlags();
} }
QStringList KeilToolChain::extraCodeModelFlags() const QStringList KeilToolchain::extraCodeModelFlags() const
{ {
return m_extraCodeModelFlags(); return m_extraCodeModelFlags();
} }
@@ -547,7 +547,7 @@ public:
setSupportedToolchainType(Constants::KEIL_TOOLCHAIN_TYPEID); setSupportedToolchainType(Constants::KEIL_TOOLCHAIN_TYPEID);
setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID, setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID,
ProjectExplorer::Constants::CXX_LANGUAGE_ID}); ProjectExplorer::Constants::CXX_LANGUAGE_ID});
setToolchainConstructor([] { return new KeilToolChain; }); setToolchainConstructor([] { return new KeilToolchain; });
setUserCreatable(true); setUserCreatable(true);
} }
@@ -560,9 +560,9 @@ private:
const Candidate &candidate, Utils::Id language) const; const Candidate &candidate, Utils::Id language) const;
}; };
void setupKeilToolChain() void setupKeilToolchain()
{ {
static KeilToolchainFactory theKeilToolChainFactory; static KeilToolchainFactory theKeilToolchainFactory;
} }
// Parse the 'tools.ini' file to fetch a toolchain version. // Parse the 'tools.ini' file to fetch a toolchain version.
@@ -709,7 +709,7 @@ Toolchains KeilToolchainFactory::autoDetectToolchain(const Candidate &candidate,
return {}; return {};
} }
const auto tc = new KeilToolChain; const auto tc = new KeilToolchain;
tc->setDetection(Toolchain::AutoDetection); tc->setDetection(Toolchain::AutoDetection);
tc->setLanguage(language); tc->setLanguage(language);
tc->setCompilerCommand(candidate.compilerPath); tc->setCompilerCommand(candidate.compilerPath);
@@ -724,7 +724,7 @@ Toolchains KeilToolchainFactory::autoDetectToolchain(const Candidate &candidate,
// KeilToolchainConfigWidget // KeilToolchainConfigWidget
KeilToolChainConfigWidget::KeilToolChainConfigWidget(KeilToolChain *tc) : KeilToolchainConfigWidget::KeilToolchainConfigWidget(KeilToolchain *tc) :
ToolchainConfigWidget(tc), ToolchainConfigWidget(tc),
m_compilerCommand(new PathChooser), m_compilerCommand(new PathChooser),
m_abiWidget(new AbiWidget) m_abiWidget(new AbiWidget)
@@ -740,22 +740,22 @@ KeilToolChainConfigWidget::KeilToolChainConfigWidget(KeilToolChain *tc) :
m_abiWidget->setEnabled(false); m_abiWidget->setEnabled(false);
addErrorLabel(); addErrorLabel();
setFromToolChain(); setFromToolchain();
connect(m_compilerCommand, &PathChooser::rawPathChanged, connect(m_compilerCommand, &PathChooser::rawPathChanged,
this, &KeilToolChainConfigWidget::handleCompilerCommandChange); this, &KeilToolchainConfigWidget::handleCompilerCommandChange);
connect(m_platformCodeGenFlagsLineEdit, &QLineEdit::editingFinished, connect(m_platformCodeGenFlagsLineEdit, &QLineEdit::editingFinished,
this, &KeilToolChainConfigWidget::handlePlatformCodeGenFlagsChange); this, &KeilToolchainConfigWidget::handlePlatformCodeGenFlagsChange);
connect(m_abiWidget, &AbiWidget::abiChanged, connect(m_abiWidget, &AbiWidget::abiChanged,
this, &ToolchainConfigWidget::dirty); this, &ToolchainConfigWidget::dirty);
} }
void KeilToolChainConfigWidget::applyImpl() void KeilToolchainConfigWidget::applyImpl()
{ {
if (toolChain()->isAutoDetected()) if (toolChain()->isAutoDetected())
return; return;
const auto tc = static_cast<KeilToolChain *>(toolChain()); const auto tc = static_cast<KeilToolchain *>(toolChain());
const QString displayName = tc->displayName(); const QString displayName = tc->displayName();
tc->setCompilerCommand(m_compilerCommand->filePath()); tc->setCompilerCommand(m_compilerCommand->filePath());
tc->m_extraCodeModelFlags.setValue(splitString(m_platformCodeGenFlagsLineEdit->text())); tc->m_extraCodeModelFlags.setValue(splitString(m_platformCodeGenFlagsLineEdit->text()));
@@ -768,29 +768,29 @@ void KeilToolChainConfigWidget::applyImpl()
const auto languageVersion = Toolchain::languageVersion(tc->language(), m_macros); const auto languageVersion = Toolchain::languageVersion(tc->language(), m_macros);
tc->predefinedMacrosCache()->insert({}, {m_macros, languageVersion}); tc->predefinedMacrosCache()->insert({}, {m_macros, languageVersion});
setFromToolChain(); setFromToolchain();
} }
bool KeilToolChainConfigWidget::isDirtyImpl() const bool KeilToolchainConfigWidget::isDirtyImpl() const
{ {
const auto tc = static_cast<KeilToolChain *>(toolChain()); const auto tc = static_cast<KeilToolchain *>(toolChain());
return m_compilerCommand->filePath() != tc->compilerCommand() return m_compilerCommand->filePath() != tc->compilerCommand()
|| m_platformCodeGenFlagsLineEdit->text() != ProcessArgs::joinArgs(tc->extraCodeModelFlags()) || m_platformCodeGenFlagsLineEdit->text() != ProcessArgs::joinArgs(tc->extraCodeModelFlags())
|| m_abiWidget->currentAbi() != tc->targetAbi() || m_abiWidget->currentAbi() != tc->targetAbi()
; ;
} }
void KeilToolChainConfigWidget::makeReadOnlyImpl() void KeilToolchainConfigWidget::makeReadOnlyImpl()
{ {
m_compilerCommand->setReadOnly(true); m_compilerCommand->setReadOnly(true);
m_platformCodeGenFlagsLineEdit->setEnabled(false); m_platformCodeGenFlagsLineEdit->setEnabled(false);
m_abiWidget->setEnabled(false); m_abiWidget->setEnabled(false);
} }
void KeilToolChainConfigWidget::setFromToolChain() void KeilToolchainConfigWidget::setFromToolchain()
{ {
const QSignalBlocker blocker(this); const QSignalBlocker blocker(this);
const auto tc = static_cast<KeilToolChain *>(toolChain()); const auto tc = static_cast<KeilToolchain *>(toolChain());
m_compilerCommand->setFilePath(tc->compilerCommand()); m_compilerCommand->setFilePath(tc->compilerCommand());
m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->extraCodeModelFlags())); m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->extraCodeModelFlags()));
m_abiWidget->setAbis({}, tc->targetAbi()); m_abiWidget->setAbis({}, tc->targetAbi());
@@ -798,7 +798,7 @@ void KeilToolChainConfigWidget::setFromToolChain()
m_abiWidget->setEnabled(haveCompiler && !tc->isAutoDetected()); m_abiWidget->setEnabled(haveCompiler && !tc->isAutoDetected());
} }
void KeilToolChainConfigWidget::handleCompilerCommandChange() void KeilToolchainConfigWidget::handleCompilerCommandChange()
{ {
const FilePath compilerPath = m_compilerCommand->filePath(); const FilePath compilerPath = m_compilerCommand->filePath();
const bool haveCompiler = compilerPath.isExecutableFile(); const bool haveCompiler = compilerPath.isExecutableFile();
@@ -818,7 +818,7 @@ void KeilToolChainConfigWidget::handleCompilerCommandChange()
emit dirty(); emit dirty();
} }
void KeilToolChainConfigWidget::handlePlatformCodeGenFlagsChange() void KeilToolchainConfigWidget::handlePlatformCodeGenFlagsChange()
{ {
const QString str1 = m_platformCodeGenFlagsLineEdit->text(); const QString str1 = m_platformCodeGenFlagsLineEdit->text();
const QString str2 = ProcessArgs::joinArgs(splitString(str1)); const QString str2 = ProcessArgs::joinArgs(splitString(str1));

2
src/plugins/baremetal/keiltoolchain.h
View File

@@ -5,6 +5,6 @@
namespace BareMetal::Internal { namespace BareMetal::Internal {
void setupKeilToolChain(); void setupKeilToolchain();
} // BareMetal::Internal } // BareMetal::Internal

64
src/plugins/baremetal/sdcctoolchain.cpp
View File

@@ -174,14 +174,14 @@ static FilePath compilerPathFromEnvironment(const QString &compilerName)
return systemEnvironment.searchInPath(compilerName); return systemEnvironment.searchInPath(compilerName);
} }
// SdccToolChainConfigWidget // SdccToolchainConfigWidget
class SdccToolChain; class SdccToolchain;
class SdccToolChainConfigWidget final : public ToolchainConfigWidget class SdccToolchainConfigWidget final : public ToolchainConfigWidget
{ {
public: public:
explicit SdccToolChainConfigWidget(SdccToolChain *tc); explicit SdccToolchainConfigWidget(SdccToolchain *tc);
private: private:
void applyImpl() final; void applyImpl() final;
@@ -197,12 +197,12 @@ private:
Macros m_macros; Macros m_macros;
}; };
// SdccToolChain // SdccToolchain
class SdccToolChain final : public Toolchain class SdccToolchain final : public Toolchain
{ {
public: public:
SdccToolChain() : Toolchain(Constants::SDCC_TOOLCHAIN_TYPEID) SdccToolchain() : Toolchain(Constants::SDCC_TOOLCHAIN_TYPEID)
{ {
setTypeDisplayName(Tr::tr("SDCC")); setTypeDisplayName(Tr::tr("SDCC"));
setTargetAbiKey("TargetAbi"); setTargetAbiKey("TargetAbi");
@@ -226,10 +226,10 @@ public:
private: private:
friend class SdccToolchainFactory; friend class SdccToolchainFactory;
friend class SdccToolChainConfigWidget; friend class SdccToolchainConfigWidget;
}; };
Toolchain::MacroInspectionRunner SdccToolChain::createMacroInspectionRunner() const Toolchain::MacroInspectionRunner SdccToolchain::createMacroInspectionRunner() const
{ {
Environment env = Environment::systemEnvironment(); Environment env = Environment::systemEnvironment();
addToEnvironment(env); addToEnvironment(env);
@@ -252,18 +252,18 @@ Toolchain::MacroInspectionRunner SdccToolChain::createMacroInspectionRunner() co
}; };
} }
LanguageExtensions SdccToolChain::languageExtensions(const QStringList &) const LanguageExtensions SdccToolchain::languageExtensions(const QStringList &) const
{ {
return LanguageExtension::None; return LanguageExtension::None;
} }
WarningFlags SdccToolChain::warningFlags(const QStringList &cxxflags) const WarningFlags SdccToolchain::warningFlags(const QStringList &cxxflags) const
{ {
Q_UNUSED(cxxflags) Q_UNUSED(cxxflags)
return WarningFlags::Default; return WarningFlags::Default;
} }
Toolchain::BuiltInHeaderPathsRunner SdccToolChain::createBuiltInHeaderPathsRunner( Toolchain::BuiltInHeaderPathsRunner SdccToolchain::createBuiltInHeaderPathsRunner(
const Environment &) const const Environment &) const
{ {
Environment env = Environment::systemEnvironment(); Environment env = Environment::systemEnvironment();
@@ -277,23 +277,23 @@ Toolchain::BuiltInHeaderPathsRunner SdccToolChain::createBuiltInHeaderPathsRunne
}; };
} }
void SdccToolChain::addToEnvironment(Environment &env) const void SdccToolchain::addToEnvironment(Environment &env) const
{ {
if (!compilerCommand().isEmpty()) if (!compilerCommand().isEmpty())
env.prependOrSetPath(compilerCommand().parentDir()); env.prependOrSetPath(compilerCommand().parentDir());
} }
std::unique_ptr<ToolchainConfigWidget> SdccToolChain::createConfigurationWidget() std::unique_ptr<ToolchainConfigWidget> SdccToolchain::createConfigurationWidget()
{ {
return std::make_unique<SdccToolChainConfigWidget>(this); return std::make_unique<SdccToolchainConfigWidget>(this);
} }
bool SdccToolChain::operator==(const Toolchain &other) const bool SdccToolchain::operator==(const Toolchain &other) const
{ {
if (!Toolchain::operator==(other)) if (!Toolchain::operator==(other))
return false; return false;
const auto customTc = static_cast<const SdccToolChain *>(&other); const auto customTc = static_cast<const SdccToolchain *>(&other);
return compilerCommand() == customTc->compilerCommand() return compilerCommand() == customTc->compilerCommand()
&& targetAbi() == customTc->targetAbi(); && targetAbi() == customTc->targetAbi();
} }
@@ -308,7 +308,7 @@ public:
setDisplayName(Tr::tr("SDCC")); setDisplayName(Tr::tr("SDCC"));
setSupportedToolchainType(Constants::SDCC_TOOLCHAIN_TYPEID); setSupportedToolchainType(Constants::SDCC_TOOLCHAIN_TYPEID);
setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID}); setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID});
setToolchainConstructor([] { return new SdccToolChain; }); setToolchainConstructor([] { return new SdccToolchain; });
setUserCreatable(true); setUserCreatable(true);
} }
@@ -320,9 +320,9 @@ private:
Toolchains autoDetectToolchain(const Candidate &candidate, Id language) const; Toolchains autoDetectToolchain(const Candidate &candidate, Id language) const;
}; };
void setupSdccToolChain() void setupSdccToolchain()
{ {
static SdccToolchainFactory theSdccToolChainFactory; static SdccToolchainFactory theSdccToolchainFactory;
} }
Toolchains SdccToolchainFactory::autoDetect(const ToolchainDetector &detector) const Toolchains SdccToolchainFactory::autoDetect(const ToolchainDetector &detector) const
@@ -428,7 +428,7 @@ Toolchains SdccToolchainFactory::autoDetectToolchain(const Candidate &candidate,
if (knownAbi.architecture() != abi.architecture()) if (knownAbi.architecture() != abi.architecture())
continue; continue;
const auto tc = new SdccToolChain; const auto tc = new SdccToolchain;
tc->setDetection(Toolchain::AutoDetection); tc->setDetection(Toolchain::AutoDetection);
tc->setLanguage(language); tc->setLanguage(language);
tc->setCompilerCommand(candidate.compilerPath); tc->setCompilerCommand(candidate.compilerPath);
@@ -445,9 +445,9 @@ Toolchains SdccToolchainFactory::autoDetectToolchain(const Candidate &candidate,
return tcs; return tcs;
} }
// SdccToolChainConfigWidget // SdccToolchainConfigWidget
SdccToolChainConfigWidget::SdccToolChainConfigWidget(SdccToolChain *tc) : SdccToolchainConfigWidget::SdccToolchainConfigWidget(SdccToolchain *tc) :
ToolchainConfigWidget(tc), ToolchainConfigWidget(tc),
m_compilerCommand(new PathChooser), m_compilerCommand(new PathChooser),
m_abiWidget(new AbiWidget) m_abiWidget(new AbiWidget)
@@ -463,17 +463,17 @@ SdccToolChainConfigWidget::SdccToolChainConfigWidget(SdccToolChain *tc) :
setFromToolchain(); setFromToolchain();
connect(m_compilerCommand, &PathChooser::rawPathChanged, connect(m_compilerCommand, &PathChooser::rawPathChanged,
this, &SdccToolChainConfigWidget::handleCompilerCommandChange); this, &SdccToolchainConfigWidget::handleCompilerCommandChange);
connect(m_abiWidget, &AbiWidget::abiChanged, connect(m_abiWidget, &AbiWidget::abiChanged,
this, &ToolchainConfigWidget::dirty); this, &ToolchainConfigWidget::dirty);
} }
void SdccToolChainConfigWidget::applyImpl() void SdccToolchainConfigWidget::applyImpl()
{ {
if (toolChain()->isAutoDetected()) if (toolChain()->isAutoDetected())
return; return;
const auto tc = static_cast<SdccToolChain *>(toolChain()); const auto tc = static_cast<SdccToolchain *>(toolChain());
const QString displayName = tc->displayName(); const QString displayName = tc->displayName();
tc->setCompilerCommand(m_compilerCommand->filePath()); tc->setCompilerCommand(m_compilerCommand->filePath());
tc->setTargetAbi(m_abiWidget->currentAbi()); tc->setTargetAbi(m_abiWidget->currentAbi());
@@ -488,31 +488,31 @@ void SdccToolChainConfigWidget::applyImpl()
setFromToolchain(); setFromToolchain();
} }
bool SdccToolChainConfigWidget::isDirtyImpl() const bool SdccToolchainConfigWidget::isDirtyImpl() const
{ {
const auto tc = static_cast<SdccToolChain *>(toolChain()); const auto tc = static_cast<SdccToolchain *>(toolChain());
return m_compilerCommand->filePath() != tc->compilerCommand() return m_compilerCommand->filePath() != tc->compilerCommand()
|| m_abiWidget->currentAbi() != tc->targetAbi() || m_abiWidget->currentAbi() != tc->targetAbi()
; ;
} }
void SdccToolChainConfigWidget::makeReadOnlyImpl() void SdccToolchainConfigWidget::makeReadOnlyImpl()
{ {
m_compilerCommand->setReadOnly(true); m_compilerCommand->setReadOnly(true);
m_abiWidget->setEnabled(false); m_abiWidget->setEnabled(false);
} }
void SdccToolChainConfigWidget::setFromToolchain() void SdccToolchainConfigWidget::setFromToolchain()
{ {
const QSignalBlocker blocker(this); const QSignalBlocker blocker(this);
const auto tc = static_cast<SdccToolChain *>(toolChain()); const auto tc = static_cast<SdccToolchain *>(toolChain());
m_compilerCommand->setFilePath(tc->compilerCommand()); m_compilerCommand->setFilePath(tc->compilerCommand());
m_abiWidget->setAbis({}, tc->targetAbi()); m_abiWidget->setAbis({}, tc->targetAbi());
const bool haveCompiler = m_compilerCommand->filePath().isExecutableFile(); const bool haveCompiler = m_compilerCommand->filePath().isExecutableFile();
m_abiWidget->setEnabled(haveCompiler && !tc->isAutoDetected()); m_abiWidget->setEnabled(haveCompiler && !tc->isAutoDetected());
} }
void SdccToolChainConfigWidget::handleCompilerCommandChange() void SdccToolchainConfigWidget::handleCompilerCommandChange()
{ {
const FilePath compilerPath = m_compilerCommand->filePath(); const FilePath compilerPath = m_compilerCommand->filePath();
const bool haveCompiler = compilerPath.isExecutableFile(); const bool haveCompiler = compilerPath.isExecutableFile();

2
src/plugins/baremetal/sdcctoolchain.h
View File

@@ -5,6 +5,6 @@
namespace BareMetal::Internal { namespace BareMetal::Internal {
void setupSdccToolChain(); void setupSdccToolchain();
} // BareMetal::Internal } // BareMetal::Internal

2
src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp
View File

@@ -996,7 +996,7 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
SysRootKitAspect::setSysRoot(k, data->sysroot); SysRootKitAspect::setSysRoot(k, data->sysroot);
for (const ToolchainDescription &cmtcd : data->toolchains) { for (const ToolchainDescription &cmtcd : data->toolchains) {
const ToolChainData tcd = findOrCreateToolChains(cmtcd); const ToolchainData tcd = findOrCreateToolChains(cmtcd);
QTC_ASSERT(!tcd.tcs.isEmpty(), continue); QTC_ASSERT(!tcd.tcs.isEmpty(), continue);
if (tcd.areTemporary) { if (tcd.areTemporary) {

2
src/plugins/cppeditor/compileroptionsbuilder_test.cpp
View File

@@ -35,7 +35,7 @@ public:
rpp.setQtVersion(Utils::QtMajorVersion::Qt5); rpp.setQtVersion(Utils::QtMajorVersion::Qt5);
rpp.setHeaderPaths(headerPaths); rpp.setHeaderPaths(headerPaths);
rpp.setConfigFileName(projectConfigFile); rpp.setConfigFileName(projectConfigFile);
ToolChainInfo tcInfo; ToolchainInfo tcInfo;
tcInfo.type = toolchainType; tcInfo.type = toolchainType;
tcInfo.targetTriple = targetTriple; tcInfo.targetTriple = targetTriple;
tcInfo.abi = Abi::fromString(targetTriple); tcInfo.abi = Abi::fromString(targetTriple);

4
src/plugins/cppeditor/cppmodelmanager.cpp
View File

@@ -1981,7 +1981,7 @@ void CppModelManager::onCoreAboutToClose()
void CppModelManager::setupFallbackProjectPart() void CppModelManager::setupFallbackProjectPart()
{ {
ToolChainInfo tcInfo; ToolchainInfo tcInfo;
RawProjectPart rpp; RawProjectPart rpp;
rpp.setMacros(definedMacros()); rpp.setMacros(definedMacros());
rpp.setHeaderPaths(headerPaths()); rpp.setHeaderPaths(headerPaths());
@@ -2001,7 +2001,7 @@ void CppModelManager::setupFallbackProjectPart()
if (sysroot.isEmpty()) if (sysroot.isEmpty())
sysroot = FilePath::fromString(defaultTc->sysRoot()); sysroot = FilePath::fromString(defaultTc->sysRoot());
Utils::Environment env = defaultKit->buildEnvironment(); Utils::Environment env = defaultKit->buildEnvironment();
tcInfo = ToolChainInfo(defaultTc, sysroot, env); tcInfo = ToolchainInfo(defaultTc, sysroot, env);
const auto macroInspectionWrapper = [runner = tcInfo.macroInspectionRunner]( const auto macroInspectionWrapper = [runner = tcInfo.macroInspectionRunner](
const QStringList &flags) { const QStringList &flags) {
Toolchain::MacroInspectionReport report = runner(flags); Toolchain::MacroInspectionReport report = runner(flags);

2
src/plugins/cppeditor/cppprojectinfogenerator.cpp
View File

@@ -121,7 +121,7 @@ ProjectPart::ConstPtr ProjectInfoGenerator::createProjectPart(
LanguageExtensions languageExtensions) LanguageExtensions languageExtensions)
{ {
RawProjectPartFlags flags; RawProjectPartFlags flags;
ToolChainInfo tcInfo; ToolchainInfo tcInfo;
if (language == Language::C) { if (language == Language::C) {
flags = rawProjectPart.flagsForC; flags = rawProjectPart.flagsForC;
tcInfo = m_projectUpdateInfo.cToolchainInfo; tcInfo = m_projectUpdateInfo.cToolchainInfo;

4
src/plugins/cppeditor/projectinfo_test.cpp
View File

@@ -65,7 +65,7 @@ public:
static QList<ProjectPart::ConstPtr> createCAndCxxProjectParts() static QList<ProjectPart::ConstPtr> createCAndCxxProjectParts()
{ {
QList<ProjectPart::ConstPtr> projectParts; QList<ProjectPart::ConstPtr> projectParts;
ToolChainInfo tcInfo; ToolchainInfo tcInfo;
// Create project part for C // Create project part for C
tcInfo.macroInspectionRunner = [](const QStringList &) { tcInfo.macroInspectionRunner = [](const QStringList &) {
@@ -484,7 +484,7 @@ public:
{ {
RawProjectPart rpp; RawProjectPart rpp;
rpp.setHeaderPaths(headerPaths); rpp.setHeaderPaths(headerPaths);
ToolChainInfo tcInfo; ToolchainInfo tcInfo;
tcInfo.type = toolchainType; tcInfo.type = toolchainType;
tcInfo.targetTriple = targetTriple; tcInfo.targetTriple = targetTriple;
tcInfo.installDir = toolchainInstallDir; tcInfo.installDir = toolchainInstallDir;

6
src/plugins/cppeditor/projectpart.cpp
View File

@@ -69,7 +69,7 @@ static Macros getProjectMacros(const RawProjectPart &rpp)
static HeaderPaths getHeaderPaths(const RawProjectPart &rpp, static HeaderPaths getHeaderPaths(const RawProjectPart &rpp,
const RawProjectPartFlags &flags, const RawProjectPartFlags &flags,
const ProjectExplorer::ToolChainInfo &tcInfo) const ProjectExplorer::ToolchainInfo &tcInfo)
{ {
HeaderPaths headerPaths; HeaderPaths headerPaths;
@@ -97,7 +97,7 @@ static HeaderPaths getHeaderPaths(const RawProjectPart &rpp,
} }
static Toolchain::MacroInspectionReport getToolchainMacros( static Toolchain::MacroInspectionReport getToolchainMacros(
const RawProjectPartFlags &flags, const ToolChainInfo &tcInfo, Utils::Language language) const RawProjectPartFlags &flags, const ToolchainInfo &tcInfo, Utils::Language language)
{ {
Toolchain::MacroInspectionReport report; Toolchain::MacroInspectionReport report;
if (tcInfo.macroInspectionRunner) { if (tcInfo.macroInspectionRunner) {
@@ -122,7 +122,7 @@ ProjectPart::ProjectPart(const Utils::FilePath &topLevelProject,
Utils::Language language, Utils::Language language,
Utils::LanguageExtensions languageExtensions, Utils::LanguageExtensions languageExtensions,
const RawProjectPartFlags &flags, const RawProjectPartFlags &flags,
const ToolChainInfo &tcInfo) const ToolchainInfo &tcInfo)
: topLevelProject(topLevelProject), : topLevelProject(topLevelProject),
displayName(displayName), displayName(displayName),
projectFile(rpp.projectFile), projectFile(rpp.projectFile),

4
src/plugins/cppeditor/projectpart.h
View File

@@ -38,7 +38,7 @@ public:
Utils::Language language = Utils::Language::Cxx, Utils::Language language = Utils::Language::Cxx,
Utils::LanguageExtensions languageExtensions = {}, Utils::LanguageExtensions languageExtensions = {},
const ProjectExplorer::RawProjectPartFlags &flags = {}, const ProjectExplorer::RawProjectPartFlags &flags = {},
const ProjectExplorer::ToolChainInfo &tcInfo = {}) const ProjectExplorer::ToolchainInfo &tcInfo = {})
{ {
return ConstPtr(new ProjectPart(topLevelProject, rpp, displayName, files, language, return ConstPtr(new ProjectPart(topLevelProject, rpp, displayName, files, language,
languageExtensions, flags, tcInfo)); languageExtensions, flags, tcInfo));
@@ -106,7 +106,7 @@ private:
Utils::Language language, Utils::Language language,
Utils::LanguageExtensions languageExtensions, Utils::LanguageExtensions languageExtensions,
const ProjectExplorer::RawProjectPartFlags &flags, const ProjectExplorer::RawProjectPartFlags &flags,
const ProjectExplorer::ToolChainInfo &tcInfo); const ProjectExplorer::ToolchainInfo &tcInfo);
CPlusPlus::LanguageFeatures deriveLanguageFeatures() const; CPlusPlus::LanguageFeatures deriveLanguageFeatures() const;

8
src/plugins/projectexplorer/projectimporter.cpp
View File

@@ -366,9 +366,9 @@ bool ProjectImporter::hasKitWithTemporaryData(Utils::Id id, const QVariant &data
}); });
} }
static ProjectImporter::ToolChainData createToolChains(const ToolchainDescription &tcd) static ProjectImporter::ToolchainData createToolChains(const ToolchainDescription &tcd)
{ {
ProjectImporter::ToolChainData data; ProjectImporter::ToolchainData data;
for (ToolchainFactory *factory : ToolchainFactory::allToolchainFactories()) { for (ToolchainFactory *factory : ToolchainFactory::allToolchainFactories()) {
data.tcs = factory->detectForImport(tcd); data.tcs = factory->detectForImport(tcd);
@@ -385,10 +385,10 @@ static ProjectImporter::ToolChainData createToolChains(const ToolchainDescriptio
return data; return data;
} }
ProjectImporter::ToolChainData ProjectImporter::ToolchainData
ProjectImporter::findOrCreateToolChains(const ToolchainDescription &tcd) const ProjectImporter::findOrCreateToolChains(const ToolchainDescription &tcd) const
{ {
ToolChainData result; ToolchainData result;
result.tcs = ToolchainManager::toolchains([&tcd](const Toolchain *tc) { result.tcs = ToolchainManager::toolchains([&tcd](const Toolchain *tc) {
return tc->language() == tcd.language && tc->matchesCompilerCommand(tcd.compilerPath); return tc->language() == tcd.language && tc->matchesCompilerCommand(tcd.compilerPath);
}); });

4
src/plugins/projectexplorer/projectimporter.h
View File

@@ -22,7 +22,7 @@ class PROJECTEXPLORER_EXPORT ProjectImporter : public QObject
{ {
Q_OBJECT Q_OBJECT
public: public:
struct ToolChainData { struct ToolchainData {
QList<Toolchain *> tcs; QList<Toolchain *> tcs;
bool areTemporary = false; bool areTemporary = false;
}; };
@@ -87,7 +87,7 @@ protected:
// Does *any* kit feature the requested data yet? // Does *any* kit feature the requested data yet?
bool hasKitWithTemporaryData(Utils::Id id, const QVariant &data) const; bool hasKitWithTemporaryData(Utils::Id id, const QVariant &data) const;
ToolChainData findOrCreateToolChains(const ToolchainDescription &tcd) const; ToolchainData findOrCreateToolChains(const ToolchainDescription &tcd) const;
private: private:
void markKitAsTemporary(Kit *k) const; void markKitAsTemporary(Kit *k) const;

6
src/plugins/projectexplorer/rawprojectpart.cpp
View File

@@ -155,7 +155,7 @@ bool KitInfo::isValid() const
return kit; return kit;
} }
ToolChainInfo::ToolChainInfo(const Toolchain *toolChain, ToolchainInfo::ToolchainInfo(const Toolchain *toolChain,
const Utils::FilePath &sysRootPath, const Utils::FilePath &sysRootPath,
const Utils::Environment &env) const Utils::Environment &env)
{ {
@@ -185,8 +185,8 @@ ProjectUpdateInfo::ProjectUpdateInfo(Project *project,
const RppGenerator &rppGenerator) const RppGenerator &rppGenerator)
: rawProjectParts(rawProjectParts) : rawProjectParts(rawProjectParts)
, rppGenerator(rppGenerator) , rppGenerator(rppGenerator)
, cToolchainInfo(ToolChainInfo(kitInfo.cToolchain, kitInfo.sysRootPath, env)) , cToolchainInfo(ToolchainInfo(kitInfo.cToolchain, kitInfo.sysRootPath, env))
, cxxToolchainInfo(ToolChainInfo(kitInfo.cxxToolchain, kitInfo.sysRootPath, env)) , cxxToolchainInfo(ToolchainInfo(kitInfo.cxxToolchain, kitInfo.sysRootPath, env))
{ {
if (project) { if (project) {
projectName = project->displayName(); projectName = project->displayName();

10
src/plugins/projectexplorer/rawprojectpart.h
View File

@@ -127,11 +127,11 @@ public:
Utils::FilePath sysRootPath; Utils::FilePath sysRootPath;
}; };
class PROJECTEXPLORER_EXPORT ToolChainInfo class PROJECTEXPLORER_EXPORT ToolchainInfo
{ {
public: public:
ToolChainInfo() = default; ToolchainInfo() = default;
ToolChainInfo(const ProjectExplorer::Toolchain *toolChain, ToolchainInfo(const ProjectExplorer::Toolchain *toolChain,
const Utils::FilePath &sysRootPath, const Utils::FilePath &sysRootPath,
const Utils::Environment &env); const Utils::Environment &env);
@@ -171,8 +171,8 @@ public:
RawProjectParts rawProjectParts; RawProjectParts rawProjectParts;
RppGenerator rppGenerator; RppGenerator rppGenerator;
ToolChainInfo cToolchainInfo; ToolchainInfo cToolchainInfo;
ToolChainInfo cxxToolchainInfo; ToolchainInfo cxxToolchainInfo;
}; };
} // namespace ProjectExplorer } // namespace ProjectExplorer

4
src/plugins/qbsprojectmanager/qbsprojectimporter.cpp
View File

@@ -183,12 +183,12 @@ Kit *QbsProjectImporter::createKit(void *directoryData) const
qtVersionData = findOrCreateQtVersion(qmakeFilePath); qtVersionData = findOrCreateQtVersion(qmakeFilePath);
} }
return createTemporaryKit(qtVersionData,[this, bgData](Kit *k) -> void { return createTemporaryKit(qtVersionData,[this, bgData](Kit *k) -> void {
QList<ToolChainData> tcData; QList<ToolchainData> tcData;
if (!bgData->cxxCompilerPath.isEmpty()) if (!bgData->cxxCompilerPath.isEmpty())
tcData << findOrCreateToolChains({bgData->cxxCompilerPath, PEConstants::CXX_LANGUAGE_ID}); tcData << findOrCreateToolChains({bgData->cxxCompilerPath, PEConstants::CXX_LANGUAGE_ID});
if (!bgData->cCompilerPath.isEmpty()) if (!bgData->cCompilerPath.isEmpty())
tcData << findOrCreateToolChains({bgData->cCompilerPath, PEConstants::C_LANGUAGE_ID}); tcData << findOrCreateToolChains({bgData->cCompilerPath, PEConstants::C_LANGUAGE_ID});
for (const ToolChainData &tc : std::as_const(tcData)) { for (const ToolchainData &tc : std::as_const(tcData)) {
if (!tc.tcs.isEmpty()) if (!tc.tcs.isEmpty())
ToolchainKitAspect::setToolchain(k, tc.tcs.first()); ToolchainKitAspect::setToolchain(k, tc.tcs.first());
} }