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

ProjectExplorer: Rename GccToolChain to GccToolchain

Browse Source 
And some related classes/comments.

Change-Id: I9a0661f1a040de594145d403c673ec2e54990e0d
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
This commit is contained in:
hjk
2023-11-27 17:14:31 +01:00
parent ddf39cd0dc
commit f130918026
13 changed files with 164 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/plugins/android/androidtoolchain.cpp
View File

@@ -47,7 +47,7 @@ static Toolchain *findToolChain(FilePath &compilerPath, Id lang, const QString &
} }
AndroidToolChain::AndroidToolChain() AndroidToolChain::AndroidToolChain()
: GccToolChain(Constants::ANDROID_TOOLCHAIN_TYPEID, Clang) : GccToolchain(Constants::ANDROID_TOOLCHAIN_TYPEID, Clang)
{ {
setTypeDisplayName(Tr::tr("Android Clang")); setTypeDisplayName(Tr::tr("Android Clang"));
} }
@@ -80,7 +80,7 @@ bool AndroidToolChain::isValid() const
const bool isChildofSdk = compilerCommand().isChildOf( const bool isChildofSdk = compilerCommand().isChildOf(
AndroidConfigurations::currentConfig().sdkLocation()); AndroidConfigurations::currentConfig().sdkLocation());
return GccToolChain::isValid() && typeId() == Constants::ANDROID_TOOLCHAIN_TYPEID return GccToolchain::isValid() && typeId() == Constants::ANDROID_TOOLCHAIN_TYPEID
&& targetAbi().isValid() && (isChildofNdk || isChildofSdk) && targetAbi().isValid() && (isChildofNdk || isChildofSdk)
&& !originalTargetTriple().isEmpty(); && !originalTargetTriple().isEmpty();
} }
@@ -104,7 +104,7 @@ void AndroidToolChain::addToEnvironment(Environment &env) const
void AndroidToolChain::fromMap(const Store &data) void AndroidToolChain::fromMap(const Store &data)
{ {
GccToolChain::fromMap(data); GccToolchain::fromMap(data);
if (hasError()) if (hasError())
return; return;
if (!isValid()) if (!isValid())
@@ -123,13 +123,13 @@ FilePath AndroidToolChain::makeCommand(const Environment &env) const
return makePath.exists() ? makePath : FilePath("make"); return makePath.exists() ? makePath : FilePath("make");
} }
GccToolChain::DetectedAbisResult AndroidToolChain::detectSupportedAbis() const GccToolchain::DetectedAbisResult AndroidToolChain::detectSupportedAbis() const
{ {
for (auto itr = ClangTargets->constBegin(); itr != ClangTargets->constEnd(); ++itr) { for (auto itr = ClangTargets->constBegin(); itr != ClangTargets->constEnd(); ++itr) {
if (itr.value() == targetAbi()) if (itr.value() == targetAbi())
return GccToolChain::DetectedAbisResult({targetAbi()}, itr.key()); return GccToolchain::DetectedAbisResult({targetAbi()}, itr.key());
} }
return GccToolChain::DetectedAbisResult({targetAbi()}, ""); return GccToolchain::DetectedAbisResult({targetAbi()}, "");
} }
@@ -238,7 +238,7 @@ ToolChainList AndroidToolchainFactory::autodetectToolChainsFromNdks(
// Do not only reset newly created toolchains. This triggers call to // Do not only reset newly created toolchains. This triggers call to
// addToEnvironment, so that e.g. JAVA_HOME gets updated. // addToEnvironment, so that e.g. JAVA_HOME gets updated.
if (auto gccTc = dynamic_cast<GccToolChain*>(tc)) if (auto gccTc = dynamic_cast<GccToolchain*>(tc))
gccTc->resetToolChain(compilerCommand); gccTc->resetToolChain(compilerCommand);
tc->setDetection(Toolchain::AutoDetection); tc->setDetection(Toolchain::AutoDetection);

2
src/plugins/android/androidtoolchain.h
View File

@@ -11,7 +11,7 @@ namespace Android::Internal {
using ToolChainList = QList<ProjectExplorer::Toolchain *>; using ToolChainList = QList<ProjectExplorer::Toolchain *>;
class AndroidToolChain : public ProjectExplorer::GccToolChain class AndroidToolChain : public ProjectExplorer::GccToolchain
{ {
public: public:
~AndroidToolChain() override; ~AndroidToolChain() override;

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

@@ -421,7 +421,7 @@ void CppModelManager::showPreprocessedFile(bool inNextSplit)
return; return;
} }
const bool isGcc = dynamic_cast<const GccToolChain *>(tc); const bool isGcc = dynamic_cast<const GccToolchain *>(tc);
const bool isMsvc = !isGcc const bool isMsvc = !isGcc
&& (tc->typeId() == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID && (tc->typeId() == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID
|| tc->typeId() == ProjectExplorer::Constants::CLANG_CL_TOOLCHAIN_TYPEID); || tc->typeId() == ProjectExplorer::Constants::CLANG_CL_TOOLCHAIN_TYPEID);

2
src/plugins/ios/iosbuildstep.cpp
View File

@@ -211,7 +211,7 @@ QStringList IosBuildStep::defaultArguments() const
} }
if (tc->typeId() == ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID if (tc->typeId() == ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID
|| tc->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID) { || tc->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID) {
auto gtc = static_cast<GccToolChain *>(tc); auto gtc = static_cast<GccToolchain *>(tc);
res << gtc->platformCodeGenFlags(); res << gtc->platformCodeGenFlags();
} }
if (!SysRootKitAspect::sysRoot(kit).isEmpty()) if (!SysRootKitAspect::sysRoot(kit).isEmpty())

28
src/plugins/ios/iosconfigurations.cpp
View File

@@ -61,7 +61,7 @@ static Q_LOGGING_CATEGORY(kitSetupLog, "qtc.ios.kitSetup", QtWarningMsg)
static Q_LOGGING_CATEGORY(iosCommonLog, "qtc.ios.common", QtWarningMsg) static Q_LOGGING_CATEGORY(iosCommonLog, "qtc.ios.common", QtWarningMsg)
} }
using ToolChainPair = std::pair<GccToolChain *, GccToolChain *>; using ToolChainPair = std::pair<GccToolchain *, GccToolchain *>;
namespace Ios { namespace Ios {
namespace Internal { namespace Internal {
@@ -98,19 +98,19 @@ static bool isSimulatorDeviceId(const Id &id)
return id == Constants::IOS_SIMULATOR_TYPE; return id == Constants::IOS_SIMULATOR_TYPE;
} }
static QList<GccToolChain *> clangToolChains(const Toolchains &toolChains) static QList<GccToolchain *> clangToolChains(const Toolchains &toolChains)
{ {
QList<GccToolChain *> clangToolChains; QList<GccToolchain *> clangToolChains;
for (Toolchain *toolChain : toolChains) for (Toolchain *toolChain : toolChains)
if (toolChain->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID) if (toolChain->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID)
clangToolChains.append(static_cast<GccToolChain *>(toolChain)); clangToolChains.append(static_cast<GccToolchain *>(toolChain));
return clangToolChains; return clangToolChains;
} }
static QList<GccToolChain *> autoDetectedIosToolChains() static QList<GccToolchain *> autoDetectedIosToolChains()
{ {
const QList<GccToolChain *> toolChains = clangToolChains(ToolchainManager::toolchains()); const QList<GccToolchain *> toolChains = clangToolChains(ToolchainManager::toolchains());
return filtered(toolChains, [](GccToolChain *toolChain) { return filtered(toolChains, [](GccToolchain *toolChain) {
return toolChain->isAutoDetected() return toolChain->isAutoDetected()
&& (toolChain->displayName().startsWith("iphone") && (toolChain->displayName().startsWith("iphone")
|| toolChain->displayName().startsWith("Apple Clang")); // TODO tool chains should be marked directly || toolChain->displayName().startsWith("Apple Clang")); // TODO tool chains should be marked directly
@@ -119,10 +119,10 @@ static QList<GccToolChain *> autoDetectedIosToolChains()
static ToolChainPair findToolChainForPlatform(const XcodePlatform &platform, static ToolChainPair findToolChainForPlatform(const XcodePlatform &platform,
const XcodePlatform::ToolchainTarget &target, const XcodePlatform::ToolchainTarget &target,
const QList<GccToolChain *> &toolChains) const QList<GccToolchain *> &toolChains)
{ {
ToolChainPair platformToolChains; ToolChainPair platformToolChains;
auto toolchainMatch = [](GccToolChain *toolChain, const FilePath &compilerPath, const QStringList &flags) { auto toolchainMatch = [](GccToolchain *toolChain, const FilePath &compilerPath, const QStringList &flags) {
return compilerPath == toolChain->compilerCommand() return compilerPath == toolChain->compilerCommand()
&& flags == toolChain->platformCodeGenFlags() && flags == toolChain->platformCodeGenFlags()
&& flags == toolChain->platformLinkerFlags(); && flags == toolChain->platformLinkerFlags();
@@ -139,7 +139,7 @@ static ToolChainPair findToolChainForPlatform(const XcodePlatform &platform,
static QHash<XcodePlatform::ToolchainTarget, ToolChainPair> findToolChains(const QList<XcodePlatform> &platforms) static QHash<XcodePlatform::ToolchainTarget, ToolChainPair> findToolChains(const QList<XcodePlatform> &platforms)
{ {
QHash<XcodePlatform::ToolchainTarget, ToolChainPair> platformToolChainHash; QHash<XcodePlatform::ToolchainTarget, ToolChainPair> platformToolChainHash;
const QList<GccToolChain *> toolChains = autoDetectedIosToolChains(); const QList<GccToolchain *> toolChains = autoDetectedIosToolChains();
for (const XcodePlatform &platform : platforms) { for (const XcodePlatform &platform : platforms) {
for (const XcodePlatform::ToolchainTarget &target : platform.targets) { for (const XcodePlatform::ToolchainTarget &target : platform.targets) {
ToolChainPair platformToolchains = findToolChainForPlatform(platform, target, ToolChainPair platformToolchains = findToolChainForPlatform(platform, target,
@@ -581,7 +581,7 @@ Toolchains IosToolchainFactory::autoDetect(const ToolchainDetector &detector) co
if (detector.device->type() != ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE) if (detector.device->type() != ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE)
return {}; return {};
QList<GccToolChain *> existingClangToolChains = clangToolChains(detector.alreadyKnown); QList<GccToolchain *> existingClangToolChains = clangToolChains(detector.alreadyKnown);
const QList<XcodePlatform> platforms = XcodeProbe::detectPlatforms().values(); const QList<XcodePlatform> platforms = XcodeProbe::detectPlatforms().values();
Toolchains toolChains; Toolchains toolChains;
toolChains.reserve(platforms.size()); toolChains.reserve(platforms.size());
@@ -589,10 +589,10 @@ Toolchains IosToolchainFactory::autoDetect(const ToolchainDetector &detector) co
for (const XcodePlatform::ToolchainTarget &target : platform.targets) { for (const XcodePlatform::ToolchainTarget &target : platform.targets) {
ToolChainPair platformToolchains = findToolChainForPlatform(platform, target, ToolChainPair platformToolchains = findToolChainForPlatform(platform, target,
existingClangToolChains); existingClangToolChains);
auto createOrAdd = [&](GccToolChain *toolChain, Id l) { auto createOrAdd = [&](GccToolchain *toolChain, Id l) {
if (!toolChain) { if (!toolChain) {
toolChain = new GccToolChain(ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID, toolChain = new GccToolchain(ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID,
GccToolChain::Clang); GccToolchain::Clang);
toolChain->setPriority(Toolchain::PriorityHigh); toolChain->setPriority(Toolchain::PriorityHigh);
toolChain->setDetection(Toolchain::AutoDetection); toolChain->setDetection(Toolchain::AutoDetection);
toolChain->setLanguage(l); toolChain->setLanguage(l);

240
src/plugins/projectexplorer/gcctoolchain.cpp
View File

@@ -104,10 +104,10 @@ const QStringList gccPredefinedMacrosOptions(Id languageId)
} }
class TargetTripleWidget; class TargetTripleWidget;
class GccToolChainConfigWidget : public ToolchainConfigWidget class GccToolchainConfigWidget : public ToolchainConfigWidget
{ {
public: public:
explicit GccToolChainConfigWidget(GccToolChain *tc); explicit GccToolchainConfigWidget(GccToolchain *tc);
private: private:
void handleCompilerCommandChange(); void handleCompilerCommandChange();
@@ -125,7 +125,7 @@ private:
AbiWidget *m_abiWidget; AbiWidget *m_abiWidget;
GccToolChain::SubType m_subType = GccToolChain::RealGcc; GccToolchain::SubType m_subType = GccToolchain::RealGcc;
PathChooser *m_compilerCommand; PathChooser *m_compilerCommand;
QLineEdit *m_platformCodeGenFlagsLineEdit; QLineEdit *m_platformCodeGenFlagsLineEdit;
@@ -206,7 +206,7 @@ static ProjectExplorer::Macros gccPredefinedMacros(const FilePath &gcc,
return predefinedMacros; return predefinedMacros;
} }
HeaderPaths GccToolChain::gccHeaderPaths(const FilePath &gcc, HeaderPaths GccToolchain::gccHeaderPaths(const FilePath &gcc,
const QStringList &arguments, const QStringList &arguments,
const Environment &env) const Environment &env)
{ {
@@ -293,13 +293,13 @@ static Abis guessGccAbi(const QString &m, const ProjectExplorer::Macros &macros)
} }
static GccToolChain::DetectedAbisResult guessGccAbi(const FilePath &path, static GccToolchain::DetectedAbisResult guessGccAbi(const FilePath &path,
const Environment &env, const Environment &env,
const Macros &macros, const Macros &macros,
const QStringList &extraArgs = {}) const QStringList &extraArgs = {})
{ {
if (path.isEmpty()) if (path.isEmpty())
return GccToolChain::DetectedAbisResult(); return GccToolchain::DetectedAbisResult();
QStringList arguments = extraArgs; QStringList arguments = extraArgs;
arguments << "-dumpmachine"; arguments << "-dumpmachine";
@@ -307,10 +307,10 @@ static GccToolChain::DetectedAbisResult guessGccAbi(const FilePath &path,
if (machine.isEmpty()) { if (machine.isEmpty()) {
// ICC does not implement the -dumpmachine option on macOS. // ICC does not implement the -dumpmachine option on macOS.
if (HostOsInfo::isMacHost() && (path.fileName() == "icc" || path.fileName() == "icpc")) if (HostOsInfo::isMacHost() && (path.fileName() == "icc" || path.fileName() == "icpc"))
return GccToolChain::DetectedAbisResult({Abi::hostAbi()}); return GccToolchain::DetectedAbisResult({Abi::hostAbi()});
return GccToolChain::DetectedAbisResult(); // no need to continue if running failed once... return GccToolchain::DetectedAbisResult(); // no need to continue if running failed once...
} }
return GccToolChain::DetectedAbisResult(guessGccAbi(machine, macros), machine); return GccToolchain::DetectedAbisResult(guessGccAbi(machine, macros), machine);
} }
static QString gccVersion(const FilePath &path, static QString gccVersion(const FilePath &path,
@@ -343,26 +343,26 @@ static FilePath gccInstallDir(const FilePath &compiler,
} }
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// GccToolChain // GccToolchain
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
static Id idForSubType(GccToolChain::SubType subType) static Id idForSubType(GccToolchain::SubType subType)
{ {
switch (subType) { switch (subType) {
case GccToolChain::RealGcc: case GccToolchain::RealGcc:
return Constants::GCC_TOOLCHAIN_TYPEID; return Constants::GCC_TOOLCHAIN_TYPEID;
case GccToolChain::Clang: case GccToolchain::Clang:
return Constants::CLANG_TOOLCHAIN_TYPEID; return Constants::CLANG_TOOLCHAIN_TYPEID;
case GccToolChain::MinGW: case GccToolchain::MinGW:
return Constants::MINGW_TOOLCHAIN_TYPEID; return Constants::MINGW_TOOLCHAIN_TYPEID;
case GccToolChain::LinuxIcc: case GccToolchain::LinuxIcc:
return Constants::LINUXICC_TOOLCHAIN_TYPEID; return Constants::LINUXICC_TOOLCHAIN_TYPEID;
} }
QTC_CHECK(false); QTC_CHECK(false);
return Constants::GCC_TOOLCHAIN_TYPEID; return Constants::GCC_TOOLCHAIN_TYPEID;
} }
GccToolChain::GccToolChain(Id typeId, SubType subType) GccToolchain::GccToolchain(Id typeId, SubType subType)
: Toolchain(typeId.isValid() ? typeId : idForSubType(subType)), m_subType(subType) : Toolchain(typeId.isValid() ? typeId : idForSubType(subType)), m_subType(subType)
{ {
setTypeDisplayName(Tr::tr("GCC")); setTypeDisplayName(Tr::tr("GCC"));
@@ -378,7 +378,7 @@ GccToolChain::GccToolChain(Id typeId, SubType subType)
} }
} }
GccToolChain::~GccToolChain() GccToolchain::~GccToolchain()
{ {
if (m_subType == Clang) { if (m_subType == Clang) {
QObject::disconnect(m_thisToolchainRemovedConnection); QObject::disconnect(m_thisToolchainRemovedConnection);
@@ -386,7 +386,7 @@ GccToolChain::~GccToolChain()
} }
} }
void GccToolChain::setSupportedAbis(const Abis &abis) void GccToolchain::setSupportedAbis(const Abis &abis)
{ {
if (m_supportedAbis == abis) if (m_supportedAbis == abis)
return; return;
@@ -395,7 +395,7 @@ void GccToolChain::setSupportedAbis(const Abis &abis)
toolChainUpdated(); toolChainUpdated();
} }
void GccToolChain::setOriginalTargetTriple(const QString &targetTriple) void GccToolchain::setOriginalTargetTriple(const QString &targetTriple)
{ {
if (m_originalTargetTriple == targetTriple) if (m_originalTargetTriple == targetTriple)
return; return;
@@ -404,7 +404,7 @@ void GccToolChain::setOriginalTargetTriple(const QString &targetTriple)
toolChainUpdated(); toolChainUpdated();
} }
void GccToolChain::setInstallDir(const FilePath &installDir) void GccToolchain::setInstallDir(const FilePath &installDir)
{ {
if (m_installDir == installDir) if (m_installDir == installDir)
return; return;
@@ -413,7 +413,7 @@ void GccToolChain::setInstallDir(const FilePath &installDir)
toolChainUpdated(); toolChainUpdated();
} }
QString GccToolChain::defaultDisplayName() const QString GccToolchain::defaultDisplayName() const
{ {
QString type = typeDisplayName(); QString type = typeDisplayName();
const QRegularExpression regexp(binaryRegexp); const QRegularExpression regexp(binaryRegexp);
@@ -430,7 +430,7 @@ QString GccToolChain::defaultDisplayName() const
compilerCommand().toUserOutput()); compilerCommand().toUserOutput());
} }
LanguageExtensions GccToolChain::defaultLanguageExtensions() const LanguageExtensions GccToolchain::defaultLanguageExtensions() const
{ {
return LanguageExtension::Gnu; return LanguageExtension::Gnu;
} }
@@ -442,23 +442,23 @@ static const Toolchains mingwToolChains()
}); });
} }
static const GccToolChain *mingwToolChainFromId(const QByteArray &id) static const GccToolchain *mingwToolChainFromId(const QByteArray &id)
{ {
if (id.isEmpty()) if (id.isEmpty())
return nullptr; return nullptr;
for (const Toolchain *tc : mingwToolChains()) { for (const Toolchain *tc : mingwToolChains()) {
if (tc->id() == id) if (tc->id() == id)
return static_cast<const GccToolChain *>(tc); return static_cast<const GccToolchain *>(tc);
} }
return nullptr; return nullptr;
} }
QString GccToolChain::originalTargetTriple() const QString GccToolchain::originalTargetTriple() const
{ {
if (m_subType == Clang) { if (m_subType == Clang) {
if (const GccToolChain *parentTC = mingwToolChainFromId(m_parentToolChainId)) if (const GccToolchain *parentTC = mingwToolChainFromId(m_parentToolChainId))
return parentTC->originalTargetTriple(); return parentTC->originalTargetTriple();
} }
@@ -467,21 +467,21 @@ QString GccToolChain::originalTargetTriple() const
return m_originalTargetTriple; return m_originalTargetTriple;
} }
QString GccToolChain::version() const QString GccToolchain::version() const
{ {
if (m_version.isEmpty()) if (m_version.isEmpty())
m_version = detectVersion(); m_version = detectVersion();
return m_version; return m_version;
} }
FilePath GccToolChain::installDir() const FilePath GccToolchain::installDir() const
{ {
if (m_installDir.isEmpty()) if (m_installDir.isEmpty())
m_installDir = detectInstallDir(); m_installDir = detectInstallDir();
return m_installDir; return m_installDir;
} }
Abis GccToolChain::supportedAbis() const Abis GccToolchain::supportedAbis() const
{ {
return m_supportedAbis; return m_supportedAbis;
} }
@@ -546,7 +546,7 @@ static QStringList filteredFlags(const QStringList &allFlags, bool considerSysro
return filtered; return filtered;
} }
Toolchain::MacroInspectionRunner GccToolChain::createMacroInspectionRunner() const Toolchain::MacroInspectionRunner GccToolchain::createMacroInspectionRunner() const
{ {
// Using a clean environment breaks ccache/distcc/etc. // Using a clean environment breaks ccache/distcc/etc.
Environment env = compilerCommand().deviceEnvironment(); Environment env = compilerCommand().deviceEnvironment();
@@ -601,7 +601,7 @@ Toolchain::MacroInspectionRunner GccToolChain::createMacroInspectionRunner() con
* @brief Parses gcc flags -std=*, -fopenmp, -fms-extensions. * @brief Parses gcc flags -std=*, -fopenmp, -fms-extensions.
* @see http://gcc.gnu.org/onlinedocs/gcc/C-Dialect-Options.html * @see http://gcc.gnu.org/onlinedocs/gcc/C-Dialect-Options.html
*/ */
LanguageExtensions GccToolChain::languageExtensions(const QStringList &cxxflags) const LanguageExtensions GccToolchain::languageExtensions(const QStringList &cxxflags) const
{ {
LanguageExtensions extensions = defaultLanguageExtensions(); LanguageExtensions extensions = defaultLanguageExtensions();
@@ -644,7 +644,7 @@ LanguageExtensions GccToolChain::languageExtensions(const QStringList &cxxflags)
return extensions; return extensions;
} }
WarningFlags GccToolChain::warningFlags(const QStringList &cflags) const WarningFlags GccToolchain::warningFlags(const QStringList &cflags) const
{ {
// based on 'LC_ALL="en" gcc -Q --help=warnings | grep enabled' // based on 'LC_ALL="en" gcc -Q --help=warnings | grep enabled'
WarningFlags flags(WarningFlags::Deprecated | WarningFlags::IgnoredQualifiers WarningFlags flags(WarningFlags::Deprecated | WarningFlags::IgnoredQualifiers
@@ -700,7 +700,7 @@ WarningFlags GccToolChain::warningFlags(const QStringList &cflags) const
return flags; return flags;
} }
FilePaths GccToolChain::includedFiles(const QStringList &flags, const FilePath &directoryPath) const FilePaths GccToolchain::includedFiles(const QStringList &flags, const FilePath &directoryPath) const
{ {
return Toolchain::includedFiles("-include", flags, directoryPath, PossiblyConcatenatedFlag::No); return Toolchain::includedFiles("-include", flags, directoryPath, PossiblyConcatenatedFlag::No);
} }
@@ -724,12 +724,12 @@ static QStringList gccPrepareArguments(const QStringList &flags,
} }
// NOTE: extraHeaderPathsFunction must NOT capture this or it's members!!! // NOTE: extraHeaderPathsFunction must NOT capture this or it's members!!!
void GccToolChain::initExtraHeaderPathsFunction(ExtraHeaderPathsFunction &&extraHeaderPathsFunction) const void GccToolchain::initExtraHeaderPathsFunction(ExtraHeaderPathsFunction &&extraHeaderPathsFunction) const
{ {
m_extraHeaderPathsFunction = std::move(extraHeaderPathsFunction); m_extraHeaderPathsFunction = std::move(extraHeaderPathsFunction);
} }
HeaderPaths GccToolChain::builtInHeaderPaths(const Environment &env, HeaderPaths GccToolchain::builtInHeaderPaths(const Environment &env,
const FilePath &compilerCommand, const FilePath &compilerCommand,
const QStringList &platformCodeGenFlags, const QStringList &platformCodeGenFlags,
OptionsReinterpreter reinterpretOptions, OptionsReinterpreter reinterpretOptions,
@@ -770,7 +770,7 @@ HeaderPaths GccToolChain::builtInHeaderPaths(const Environment &env,
return paths; return paths;
} }
Toolchain::BuiltInHeaderPathsRunner GccToolChain::createBuiltInHeaderPathsRunner( Toolchain::BuiltInHeaderPathsRunner GccToolchain::createBuiltInHeaderPathsRunner(
const Environment &env) const const Environment &env) const
{ {
// Using a clean environment breaks ccache/distcc/etc. // Using a clean environment breaks ccache/distcc/etc.
@@ -824,12 +824,12 @@ Toolchain::BuiltInHeaderPathsRunner GccToolChain::createBuiltInHeaderPathsRunner
}; };
} }
void GccToolChain::addCommandPathToEnvironment(const FilePath &command, Environment &env) void GccToolchain::addCommandPathToEnvironment(const FilePath &command, Environment &env)
{ {
env.prependOrSetPath(command.parentDir()); env.prependOrSetPath(command.parentDir());
} }
void GccToolChain::addToEnvironment(Environment &env) const void GccToolchain::addToEnvironment(Environment &env) const
{ {
// On Windows gcc invokes cc1plus which is in libexec directory. // On Windows gcc invokes cc1plus which is in libexec directory.
// cc1plus depends on libwinpthread-1.dll which is in bin, so bin must be in the PATH. // cc1plus depends on libwinpthread-1.dll which is in bin, so bin must be in the PATH.
@@ -849,7 +849,7 @@ void GccToolChain::addToEnvironment(Environment &env) const
} }
} }
QStringList GccToolChain::suggestedMkspecList() const QStringList GccToolchain::suggestedMkspecList() const
{ {
if (m_subType == LinuxIcc) if (m_subType == LinuxIcc)
return {QString("linux-icc-%1").arg(targetAbi().wordWidth())}; return {QString("linux-icc-%1").arg(targetAbi().wordWidth())};
@@ -930,7 +930,7 @@ static FilePath mingwAwareMakeCommand(const Environment &environment)
return FilePath::fromString(makes.first()); return FilePath::fromString(makes.first());
} }
FilePath GccToolChain::makeCommand(const Environment &environment) const FilePath GccToolchain::makeCommand(const Environment &environment) const
{ {
if (m_subType == Clang || m_subType == MinGW) if (m_subType == Clang || m_subType == MinGW)
return mingwAwareMakeCommand(environment); return mingwAwareMakeCommand(environment);
@@ -939,7 +939,7 @@ FilePath GccToolChain::makeCommand(const Environment &environment) const
return tmp.isEmpty() ? "make" : tmp; return tmp.isEmpty() ? "make" : tmp;
} }
QList<OutputLineParser *> GccToolChain::createOutputParsers() const QList<OutputLineParser *> GccToolchain::createOutputParsers() const
{ {
if (m_subType == LinuxIcc) if (m_subType == LinuxIcc)
return LinuxIccParser::iccParserSuite(); return LinuxIccParser::iccParserSuite();
@@ -950,7 +950,7 @@ QList<OutputLineParser *> GccToolChain::createOutputParsers() const
return GccParser::gccParserSuite(); return GccParser::gccParserSuite();
} }
void GccToolChain::resetToolChain(const FilePath &path) void GccToolchain::resetToolChain(const FilePath &path)
{ {
bool resetDisplayName = (displayName() == defaultDisplayName()); bool resetDisplayName = (displayName() == defaultDisplayName());
@@ -973,7 +973,7 @@ void GccToolChain::resetToolChain(const FilePath &path)
toolChainUpdated(); toolChainUpdated();
} }
void GccToolChain::setPlatformCodeGenFlags(const QStringList &flags) void GccToolchain::setPlatformCodeGenFlags(const QStringList &flags)
{ {
if (flags != m_platformCodeGenFlags) { if (flags != m_platformCodeGenFlags) {
m_platformCodeGenFlags = flags; m_platformCodeGenFlags = flags;
@@ -981,7 +981,7 @@ void GccToolChain::setPlatformCodeGenFlags(const QStringList &flags)
} }
} }
QStringList GccToolChain::extraCodeModelFlags() const QStringList GccToolchain::extraCodeModelFlags() const
{ {
return platformCodeGenFlags(); return platformCodeGenFlags();
} }
@@ -989,12 +989,12 @@ QStringList GccToolChain::extraCodeModelFlags() const
/*! /*!
Code gen flags that have to be passed to the compiler. Code gen flags that have to be passed to the compiler.
*/ */
QStringList GccToolChain::platformCodeGenFlags() const QStringList GccToolchain::platformCodeGenFlags() const
{ {
return m_platformCodeGenFlags; return m_platformCodeGenFlags;
} }
void GccToolChain::setPlatformLinkerFlags(const QStringList &flags) void GccToolchain::setPlatformLinkerFlags(const QStringList &flags)
{ {
if (flags != m_platformLinkerFlags) { if (flags != m_platformLinkerFlags) {
m_platformLinkerFlags = flags; m_platformLinkerFlags = flags;
@@ -1007,12 +1007,12 @@ void GccToolChain::setPlatformLinkerFlags(const QStringList &flags)
For example: \c{-arch armv7} For example: \c{-arch armv7}
*/ */
QStringList GccToolChain::platformLinkerFlags() const QStringList GccToolchain::platformLinkerFlags() const
{ {
return m_platformLinkerFlags; return m_platformLinkerFlags;
} }
void GccToolChain::toMap(Store &data) const void GccToolchain::toMap(Store &data) const
{ {
Toolchain::toMap(data); Toolchain::toMap(data);
data.insert(compilerPlatformCodeGenFlagsKeyC, m_platformCodeGenFlags); data.insert(compilerPlatformCodeGenFlagsKeyC, m_platformCodeGenFlags);
@@ -1026,7 +1026,7 @@ void GccToolChain::toMap(Store &data) const
} }
} }
void GccToolChain::fromMap(const Store &data) void GccToolchain::fromMap(const Store &data)
{ {
Toolchain::fromMap(data); Toolchain::fromMap(data);
if (hasError()) if (hasError())
@@ -1051,23 +1051,23 @@ void GccToolChain::fromMap(const Store &data)
} }
} }
bool GccToolChain::operator ==(const Toolchain &other) const bool GccToolchain::operator ==(const Toolchain &other) const
{ {
if (!Toolchain::operator ==(other)) if (!Toolchain::operator ==(other))
return false; return false;
auto gccTc = static_cast<const GccToolChain *>(&other); auto gccTc = static_cast<const GccToolchain *>(&other);
return compilerCommand() == gccTc->compilerCommand() && targetAbi() == gccTc->targetAbi() return compilerCommand() == gccTc->compilerCommand() && targetAbi() == gccTc->targetAbi()
&& m_platformCodeGenFlags == gccTc->m_platformCodeGenFlags && m_platformCodeGenFlags == gccTc->m_platformCodeGenFlags
&& m_platformLinkerFlags == gccTc->m_platformLinkerFlags; && m_platformLinkerFlags == gccTc->m_platformLinkerFlags;
} }
std::unique_ptr<ToolchainConfigWidget> GccToolChain::createConfigurationWidget() std::unique_ptr<ToolchainConfigWidget> GccToolchain::createConfigurationWidget()
{ {
return std::make_unique<GccToolChainConfigWidget>(this); return std::make_unique<GccToolchainConfigWidget>(this);
} }
void GccToolChain::updateSupportedAbis() const void GccToolchain::updateSupportedAbis() const
{ {
if (m_supportedAbis.isEmpty()) { if (m_supportedAbis.isEmpty()) {
const DetectedAbisResult detected = detectSupportedAbis(); const DetectedAbisResult detected = detectSupportedAbis();
@@ -1076,12 +1076,12 @@ void GccToolChain::updateSupportedAbis() const
} }
} }
void GccToolChain::setOptionsReinterpreter(const OptionsReinterpreter &optionsReinterpreter) void GccToolchain::setOptionsReinterpreter(const OptionsReinterpreter &optionsReinterpreter)
{ {
m_optionsReinterpreter = optionsReinterpreter; m_optionsReinterpreter = optionsReinterpreter;
} }
GccToolChain::DetectedAbisResult GccToolChain::detectSupportedAbis() const GccToolchain::DetectedAbisResult GccToolchain::detectSupportedAbis() const
{ {
Environment env = compilerCommand().deviceEnvironment(); Environment env = compilerCommand().deviceEnvironment();
addToEnvironment(env); addToEnvironment(env);
@@ -1092,7 +1092,7 @@ GccToolChain::DetectedAbisResult GccToolChain::detectSupportedAbis() const
platformCodeGenFlags()); platformCodeGenFlags());
} }
QString GccToolChain::detectVersion() const QString GccToolchain::detectVersion() const
{ {
Environment env = compilerCommand().deviceEnvironment(); Environment env = compilerCommand().deviceEnvironment();
addToEnvironment(env); addToEnvironment(env);
@@ -1100,7 +1100,7 @@ QString GccToolChain::detectVersion() const
filteredFlags(platformCodeGenFlags(), true)); filteredFlags(platformCodeGenFlags(), true));
} }
FilePath GccToolChain::detectInstallDir() const FilePath GccToolchain::detectInstallDir() const
{ {
Environment env = compilerCommand().deviceEnvironment(); Environment env = compilerCommand().deviceEnvironment();
addToEnvironment(env); addToEnvironment(env);
@@ -1256,22 +1256,22 @@ static Utils::FilePaths renesasRl78SearchPathsFromRegistry()
static Toolchain *constructRealGccToolchain() static Toolchain *constructRealGccToolchain()
{ {
return new GccToolChain(Constants::GCC_TOOLCHAIN_TYPEID, GccToolChain::RealGcc); return new GccToolchain(Constants::GCC_TOOLCHAIN_TYPEID, GccToolchain::RealGcc);
} }
static Toolchain *constructClangToolchain() static Toolchain *constructClangToolchain()
{ {
return new GccToolChain(Constants::CLANG_TOOLCHAIN_TYPEID, GccToolChain::Clang); return new GccToolchain(Constants::CLANG_TOOLCHAIN_TYPEID, GccToolchain::Clang);
} }
static Toolchain *constructMinGWToolchain() static Toolchain *constructMinGWToolchain()
{ {
return new GccToolChain(Constants::MINGW_TOOLCHAIN_TYPEID, GccToolChain::MinGW); return new GccToolchain(Constants::MINGW_TOOLCHAIN_TYPEID, GccToolchain::MinGW);
} }
static Toolchain *constructLinuxIccToolchain() static Toolchain *constructLinuxIccToolchain()
{ {
return new GccToolChain(Constants::LINUXICC_TOOLCHAIN_TYPEID, GccToolChain::LinuxIcc); return new GccToolchain(Constants::LINUXICC_TOOLCHAIN_TYPEID, GccToolchain::LinuxIcc);
} }
namespace Internal { namespace Internal {
@@ -1279,26 +1279,26 @@ namespace Internal {
class GccToolchainFactory final : public ToolchainFactory class GccToolchainFactory final : public ToolchainFactory
{ {
public: public:
explicit GccToolchainFactory(GccToolChain::SubType subType) explicit GccToolchainFactory(GccToolchain::SubType subType)
: m_autoDetecting(subType == GccToolChain::RealGcc) : m_autoDetecting(subType == GccToolchain::RealGcc)
{ {
switch (subType) { switch (subType) {
case GccToolChain::RealGcc: case GccToolchain::RealGcc:
setDisplayName(Tr::tr("GCC")); setDisplayName(Tr::tr("GCC"));
setSupportedToolchainType(Constants::GCC_TOOLCHAIN_TYPEID); setSupportedToolchainType(Constants::GCC_TOOLCHAIN_TYPEID);
setToolchainConstructor(&constructRealGccToolchain); setToolchainConstructor(&constructRealGccToolchain);
break; break;
case GccToolChain::Clang: case GccToolchain::Clang:
setDisplayName(Tr::tr("Clang")); setDisplayName(Tr::tr("Clang"));
setSupportedToolchainType(Constants::CLANG_TOOLCHAIN_TYPEID); setSupportedToolchainType(Constants::CLANG_TOOLCHAIN_TYPEID);
setToolchainConstructor(&constructClangToolchain); setToolchainConstructor(&constructClangToolchain);
break; break;
case GccToolChain::MinGW: case GccToolchain::MinGW:
setDisplayName(Tr::tr("MinGW")); setDisplayName(Tr::tr("MinGW"));
setSupportedToolchainType(Constants::MINGW_TOOLCHAIN_TYPEID); setSupportedToolchainType(Constants::MINGW_TOOLCHAIN_TYPEID);
setToolchainConstructor(&constructMinGWToolchain); setToolchainConstructor(&constructMinGWToolchain);
break; break;
case GccToolChain::LinuxIcc: case GccToolchain::LinuxIcc:
setDisplayName(Tr::tr("ICC")); setDisplayName(Tr::tr("ICC"));
setSupportedToolchainType(Constants::LINUXICC_TOOLCHAIN_TYPEID); setSupportedToolchainType(Constants::LINUXICC_TOOLCHAIN_TYPEID);
setToolchainConstructor(&constructLinuxIccToolchain); setToolchainConstructor(&constructLinuxIccToolchain);
@@ -1316,9 +1316,9 @@ private:
const Id language, const Id language,
const Id requiredTypeId, const Id requiredTypeId,
const Toolchains &known, const Toolchains &known,
const GccToolChain::SubType subType); const GccToolchain::SubType subType);
static Toolchains autoDetectToolChain(const ToolchainDescription &tcd, static Toolchains autoDetectToolChain(const ToolchainDescription &tcd,
const GccToolChain::SubType subType); const GccToolchain::SubType subType);
static Toolchains autoDetectSdkClangToolchain(const Toolchains &known); static Toolchains autoDetectSdkClangToolchain(const Toolchains &known);
const bool m_autoDetecting; const bool m_autoDetecting;
@@ -1327,16 +1327,16 @@ private:
void setupGccToolchains() void setupGccToolchains()
{ {
#ifndef Q_OS_WIN #ifndef Q_OS_WIN
static GccToolchainFactory theLinuxIccToolchainFactory{GccToolChain::LinuxIcc}; static GccToolchainFactory theLinuxIccToolchainFactory{GccToolchain::LinuxIcc};
#endif #endif
#ifndef Q_OS_MACOS #ifndef Q_OS_MACOS
// Mingw offers cross-compiling to windows // Mingw offers cross-compiling to windows
static GccToolchainFactory theMingwToolchainFactory{GccToolChain::MinGW}; static GccToolchainFactory theMingwToolchainFactory{GccToolchain::MinGW};
#endif #endif
static GccToolchainFactory theGccToolchainFactory{GccToolChain::RealGcc}; static GccToolchainFactory theGccToolchainFactory{GccToolchain::RealGcc};
static GccToolchainFactory theClangToolchainFactory{GccToolChain::Clang}; static GccToolchainFactory theClangToolchainFactory{GccToolchain::Clang};
} }
static FilePaths findCompilerCandidates(OsType os, static FilePaths findCompilerCandidates(OsType os,
@@ -1458,14 +1458,14 @@ Toolchains GccToolchainFactory::autoDetect(const ToolchainDetector &detector) co
Constants::CXX_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID,
Constants::LINUXICC_TOOLCHAIN_TYPEID, Constants::LINUXICC_TOOLCHAIN_TYPEID,
detector.alreadyKnown, detector.alreadyKnown,
GccToolChain::LinuxIcc); GccToolchain::LinuxIcc);
result += autoDetectToolchains(findCompilerCandidates(os, executables, "icc", true), result += autoDetectToolchains(findCompilerCandidates(os, executables, "icc", true),
Constants::C_LANGUAGE_ID, Constants::C_LANGUAGE_ID,
Constants::LINUXICC_TOOLCHAIN_TYPEID, Constants::LINUXICC_TOOLCHAIN_TYPEID,
detector.alreadyKnown, detector.alreadyKnown,
GccToolChain::LinuxIcc); GccToolchain::LinuxIcc);
// Clang // Clang
@@ -1476,12 +1476,12 @@ Toolchains GccToolchainFactory::autoDetect(const ToolchainDetector &detector) co
Constants::CXX_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID,
Constants::CLANG_TOOLCHAIN_TYPEID, Constants::CLANG_TOOLCHAIN_TYPEID,
detector.alreadyKnown, detector.alreadyKnown,
GccToolChain::Clang)); GccToolchain::Clang));
tcs.append(autoDetectToolchains(findCompilerCandidates(os, executables, "clang", true), tcs.append(autoDetectToolchains(findCompilerCandidates(os, executables, "clang", true),
Constants::C_LANGUAGE_ID, Constants::C_LANGUAGE_ID,
Constants::CLANG_TOOLCHAIN_TYPEID, Constants::CLANG_TOOLCHAIN_TYPEID,
detector.alreadyKnown, detector.alreadyKnown,
GccToolChain::Clang)); GccToolchain::Clang));
known.append(tcs); known.append(tcs);
tcs.append(autoDetectSdkClangToolchain(known)); tcs.append(autoDetectSdkClangToolchain(known));
@@ -1494,12 +1494,12 @@ Toolchains GccToolchainFactory::autoDetect(const ToolchainDetector &detector) co
Constants::CXX_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID,
Constants::GCC_TOOLCHAIN_TYPEID, Constants::GCC_TOOLCHAIN_TYPEID,
detector.alreadyKnown, detector.alreadyKnown,
GccToolChain::RealGcc /*sic!*/); GccToolchain::RealGcc /*sic!*/);
result += autoDetectToolchains(findCompilerCandidates(os, executables, "gcc", true), result += autoDetectToolchains(findCompilerCandidates(os, executables, "gcc", true),
Constants::C_LANGUAGE_ID, Constants::C_LANGUAGE_ID,
Constants::GCC_TOOLCHAIN_TYPEID, Constants::GCC_TOOLCHAIN_TYPEID,
detector.alreadyKnown, detector.alreadyKnown,
GccToolChain::RealGcc /*sic!*/); GccToolchain::RealGcc /*sic!*/);
return result; return result;
} }
@@ -1519,7 +1519,7 @@ Toolchains GccToolchainFactory::detectForImport(const ToolchainDescription &tcd)
if ((tcd.language == Constants::CXX_LANGUAGE_ID && fileName.startsWith("icpc")) || if ((tcd.language == Constants::CXX_LANGUAGE_ID && fileName.startsWith("icpc")) ||
(tcd.language == Constants::C_LANGUAGE_ID && fileName.startsWith("icc"))) { (tcd.language == Constants::C_LANGUAGE_ID && fileName.startsWith("icc"))) {
result += autoDetectToolChain(tcd, GccToolChain::LinuxIcc); result += autoDetectToolChain(tcd, GccToolchain::LinuxIcc);
} }
bool isCCompiler = tcd.language == Constants::C_LANGUAGE_ID bool isCCompiler = tcd.language == Constants::C_LANGUAGE_ID
@@ -1531,7 +1531,7 @@ Toolchains GccToolchainFactory::detectForImport(const ToolchainDescription &tcd)
|| (fileName == "c++" && resolvedSymlinksFileName.contains("clang"))); || (fileName == "c++" && resolvedSymlinksFileName.contains("clang")));
if (isCCompiler || isCxxCompiler) if (isCCompiler || isCxxCompiler)
result += autoDetectToolChain(tcd, GccToolChain::Clang); result += autoDetectToolChain(tcd, GccToolchain::Clang);
// GCC // GCC
@@ -1546,7 +1546,7 @@ Toolchains GccToolchainFactory::detectForImport(const ToolchainDescription &tcd)
|| (fileName == "c++" && !resolvedSymlinksFileName.contains("clang"))); || (fileName == "c++" && !resolvedSymlinksFileName.contains("clang")));
if (isCCompiler || isCxxCompiler) if (isCCompiler || isCxxCompiler)
result += autoDetectToolChain(tcd, GccToolChain::RealGcc); result += autoDetectToolChain(tcd, GccToolchain::RealGcc);
return result; return result;
} }
@@ -1562,14 +1562,14 @@ Toolchains GccToolchainFactory::autoDetectSdkClangToolchain(const Toolchains &kn
return {existingTc}; return {existingTc};
} }
return {autoDetectToolChain({compilerPath, Constants::C_LANGUAGE_ID}, GccToolChain::Clang)}; return {autoDetectToolChain({compilerPath, Constants::C_LANGUAGE_ID}, GccToolchain::Clang)};
} }
Toolchains GccToolchainFactory::autoDetectToolchains(const FilePaths &compilerPaths, Toolchains GccToolchainFactory::autoDetectToolchains(const FilePaths &compilerPaths,
const Id language, const Id language,
const Id requiredTypeId, const Id requiredTypeId,
const Toolchains &known, const Toolchains &known,
const GccToolChain::SubType subType) const GccToolchain::SubType subType)
{ {
Toolchains existingCandidates = filtered(known, Toolchains existingCandidates = filtered(known,
[language](const Toolchain *tc) { return tc->language() == language; }); [language](const Toolchain *tc) { return tc->language() == language; });
@@ -1617,12 +1617,12 @@ Toolchains GccToolchainFactory::autoDetectToolchains(const FilePaths &compilerPa
} }
Toolchains GccToolchainFactory::autoDetectToolChain(const ToolchainDescription &tcd, Toolchains GccToolchainFactory::autoDetectToolChain(const ToolchainDescription &tcd,
GccToolChain::SubType subType) GccToolchain::SubType subType)
{ {
Toolchains result; Toolchains result;
Environment systemEnvironment = tcd.compilerPath.deviceEnvironment(); Environment systemEnvironment = tcd.compilerPath.deviceEnvironment();
GccToolChain::addCommandPathToEnvironment(tcd.compilerPath, systemEnvironment); GccToolchain::addCommandPathToEnvironment(tcd.compilerPath, systemEnvironment);
const FilePath localCompilerPath = findLocalCompiler(tcd.compilerPath, systemEnvironment); const FilePath localCompilerPath = findLocalCompiler(tcd.compilerPath, systemEnvironment);
if (ToolchainManager::isBadToolchain(localCompilerPath)) if (ToolchainManager::isBadToolchain(localCompilerPath))
return result; return result;
@@ -1633,15 +1633,15 @@ Toolchains GccToolchainFactory::autoDetectToolChain(const ToolchainDescription &
ToolchainManager::addBadToolchain(localCompilerPath); ToolchainManager::addBadToolchain(localCompilerPath);
return result; return result;
} }
const GccToolChain::DetectedAbisResult detectedAbis = guessGccAbi(localCompilerPath, const GccToolchain::DetectedAbisResult detectedAbis = guessGccAbi(localCompilerPath,
systemEnvironment, systemEnvironment,
macros); macros);
for (const Abi &abi : detectedAbis.supportedAbis) { for (const Abi &abi : detectedAbis.supportedAbis) {
GccToolChain::SubType detectedSubType = subType; GccToolchain::SubType detectedSubType = subType;
if (detectedSubType == GccToolChain::RealGcc && abi.osFlavor() == Abi::WindowsMSysFlavor) if (detectedSubType == GccToolchain::RealGcc && abi.osFlavor() == Abi::WindowsMSysFlavor)
detectedSubType = GccToolChain::MinGW; detectedSubType = GccToolchain::MinGW;
auto tc = new GccToolChain({}, detectedSubType); auto tc = new GccToolchain({}, detectedSubType);
tc->setLanguage(tcd.language); tc->setLanguage(tcd.language);
tc->setDetection(Toolchain::AutoDetection); tc->setDetection(Toolchain::AutoDetection);
@@ -1655,7 +1655,7 @@ Toolchains GccToolchainFactory::autoDetectToolChain(const ToolchainDescription &
tc->setOriginalTargetTriple(detectedAbis.originalTargetTriple); tc->setOriginalTargetTriple(detectedAbis.originalTargetTriple);
tc->setDisplayName(tc->defaultDisplayName()); // reset displayname tc->setDisplayName(tc->defaultDisplayName()); // reset displayname
// lower priority of g++/gcc on macOS - usually just a frontend to clang // lower priority of g++/gcc on macOS - usually just a frontend to clang
if (detectedSubType == GccToolChain::RealGcc && abi.binaryFormat() == Abi::MachOFormat) if (detectedSubType == GccToolchain::RealGcc && abi.binaryFormat() == Abi::MachOFormat)
tc->setPriority(Toolchain::PriorityLow); tc->setPriority(Toolchain::PriorityLow);
result.append(tc); result.append(tc);
} }
@@ -1663,7 +1663,7 @@ Toolchains GccToolchainFactory::autoDetectToolChain(const ToolchainDescription &
} }
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// GccToolChainConfigWidget // GccToolchainConfigWidget
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
class TargetTripleWidget : public QWidget class TargetTripleWidget : public QWidget
@@ -1707,7 +1707,7 @@ private:
}; };
} }
GccToolChainConfigWidget::GccToolChainConfigWidget(GccToolChain *tc) : GccToolchainConfigWidget::GccToolchainConfigWidget(GccToolchain *tc) :
ToolchainConfigWidget(tc), ToolchainConfigWidget(tc),
m_abiWidget(new AbiWidget), m_abiWidget(new AbiWidget),
m_subType(tc->m_subType), m_subType(tc->m_subType),
@@ -1735,16 +1735,16 @@ GccToolChainConfigWidget::GccToolChainConfigWidget(GccToolChain *tc) :
setFromToolchain(); setFromToolchain();
connect(m_compilerCommand, &PathChooser::rawPathChanged, connect(m_compilerCommand, &PathChooser::rawPathChanged,
this, &GccToolChainConfigWidget::handleCompilerCommandChange); this, &GccToolchainConfigWidget::handleCompilerCommandChange);
connect(m_platformCodeGenFlagsLineEdit, &QLineEdit::editingFinished, connect(m_platformCodeGenFlagsLineEdit, &QLineEdit::editingFinished,
this, &GccToolChainConfigWidget::handlePlatformCodeGenFlagsChange); this, &GccToolchainConfigWidget::handlePlatformCodeGenFlagsChange);
connect(m_platformLinkerFlagsLineEdit, &QLineEdit::editingFinished, connect(m_platformLinkerFlagsLineEdit, &QLineEdit::editingFinished,
this, &GccToolChainConfigWidget::handlePlatformLinkerFlagsChange); this, &GccToolchainConfigWidget::handlePlatformLinkerFlagsChange);
connect(m_abiWidget, &AbiWidget::abiChanged, this, &ToolchainConfigWidget::dirty); connect(m_abiWidget, &AbiWidget::abiChanged, this, &ToolchainConfigWidget::dirty);
connect(m_targetTripleWidget, &TargetTripleWidget::valueChanged, connect(m_targetTripleWidget, &TargetTripleWidget::valueChanged,
this, &ToolchainConfigWidget::dirty); this, &ToolchainConfigWidget::dirty);
if (m_subType == GccToolChain::Clang) { if (m_subType == GccToolchain::Clang) {
if (!HostOsInfo::isWindowsHost() || tc->typeId() != Constants::CLANG_TOOLCHAIN_TYPEID) if (!HostOsInfo::isWindowsHost() || tc->typeId() != Constants::CLANG_TOOLCHAIN_TYPEID)
return; return;
@@ -1783,12 +1783,12 @@ GccToolChainConfigWidget::GccToolChainConfigWidget(GccToolChain *tc) :
} }
} }
void GccToolChainConfigWidget::applyImpl() void GccToolchainConfigWidget::applyImpl()
{ {
if (toolChain()->isAutoDetected()) if (toolChain()->isAutoDetected())
return; return;
auto tc = static_cast<GccToolChain *>(toolChain()); auto tc = static_cast<GccToolchain *>(toolChain());
Q_ASSERT(tc); Q_ASSERT(tc);
QString displayName = tc->displayName(); QString displayName = tc->displayName();
tc->setCompilerCommand(m_compilerCommand->filePath()); tc->setCompilerCommand(m_compilerCommand->filePath());
@@ -1812,7 +1812,7 @@ void GccToolChainConfigWidget::applyImpl()
Toolchain::languageVersion(tc->language(), Toolchain::languageVersion(tc->language(),
m_macros)}); m_macros)});
if (m_subType == GccToolChain::Clang && m_parentToolchainCombo) { if (m_subType == GccToolchain::Clang && m_parentToolchainCombo) {
tc->m_parentToolChainId.clear(); tc->m_parentToolChainId.clear();
@@ -1830,11 +1830,11 @@ void GccToolChainConfigWidget::applyImpl()
} }
} }
void GccToolChainConfigWidget::setFromToolchain() void GccToolchainConfigWidget::setFromToolchain()
{ {
// subwidgets are not yet connected! // subwidgets are not yet connected!
QSignalBlocker blocker(this); QSignalBlocker blocker(this);
auto tc = static_cast<GccToolChain *>(toolChain()); auto tc = static_cast<GccToolchain *>(toolChain());
m_compilerCommand->setFilePath(tc->compilerCommand()); m_compilerCommand->setFilePath(tc->compilerCommand());
m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->platformCodeGenFlags(), m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->platformCodeGenFlags(),
HostOsInfo::hostOs())); HostOsInfo::hostOs()));
@@ -1850,9 +1850,9 @@ void GccToolChainConfigWidget::setFromToolchain()
updateParentToolChainComboBox(); updateParentToolChainComboBox();
} }
bool GccToolChainConfigWidget::isDirtyImpl() const bool GccToolchainConfigWidget::isDirtyImpl() const
{ {
auto tc = static_cast<GccToolChain *>(toolChain()); auto tc = static_cast<GccToolchain *>(toolChain());
if (m_compilerCommand->filePath() != tc->compilerCommand() if (m_compilerCommand->filePath() != tc->compilerCommand()
|| m_platformCodeGenFlagsLineEdit->text() || m_platformCodeGenFlagsLineEdit->text()
@@ -1868,12 +1868,12 @@ bool GccToolChainConfigWidget::isDirtyImpl() const
if (!m_parentToolchainCombo) if (!m_parentToolchainCombo)
return false; return false;
const GccToolChain *parentTC = mingwToolChainFromId(tc->m_parentToolChainId); const GccToolchain *parentTC = mingwToolChainFromId(tc->m_parentToolChainId);
const QByteArray parentId = parentTC ? parentTC->id() : QByteArray(); const QByteArray parentId = parentTC ? parentTC->id() : QByteArray();
return parentId != m_parentToolchainCombo->currentData(); return parentId != m_parentToolchainCombo->currentData();
} }
void GccToolChainConfigWidget::makeReadOnlyImpl() void GccToolchainConfigWidget::makeReadOnlyImpl()
{ {
m_compilerCommand->setReadOnly(true); m_compilerCommand->setReadOnly(true);
if (m_abiWidget) if (m_abiWidget)
@@ -1887,7 +1887,7 @@ void GccToolChainConfigWidget::makeReadOnlyImpl()
m_parentToolchainCombo->setEnabled(false); m_parentToolchainCombo->setEnabled(false);
} }
void GccToolChainConfigWidget::handleCompilerCommandChange() void GccToolchainConfigWidget::handleCompilerCommandChange()
{ {
if (!m_abiWidget) if (!m_abiWidget)
return; return;
@@ -1903,7 +1903,7 @@ void GccToolChainConfigWidget::handleCompilerCommandChange()
} }
if (haveCompiler) { if (haveCompiler) {
Environment env = path.deviceEnvironment(); Environment env = path.deviceEnvironment();
GccToolChain::addCommandPathToEnvironment(path, env); GccToolchain::addCommandPathToEnvironment(path, env);
QStringList args = gccPredefinedMacrosOptions(Constants::CXX_LANGUAGE_ID) QStringList args = gccPredefinedMacrosOptions(Constants::CXX_LANGUAGE_ID)
+ splitString(m_platformCodeGenFlagsLineEdit->text()); + splitString(m_platformCodeGenFlagsLineEdit->text());
const FilePath localCompilerPath = findLocalCompiler(path, env); const FilePath localCompilerPath = findLocalCompiler(path, env);
@@ -1922,7 +1922,7 @@ void GccToolChainConfigWidget::handleCompilerCommandChange()
emit dirty(); emit dirty();
} }
void GccToolChainConfigWidget::handlePlatformCodeGenFlagsChange() void GccToolchainConfigWidget::handlePlatformCodeGenFlagsChange()
{ {
QString str1 = m_platformCodeGenFlagsLineEdit->text(); QString str1 = m_platformCodeGenFlagsLineEdit->text();
QString str2 = ProcessArgs::joinArgs(splitString(str1)); QString str2 = ProcessArgs::joinArgs(splitString(str1));
@@ -1932,7 +1932,7 @@ void GccToolChainConfigWidget::handlePlatformCodeGenFlagsChange()
handleCompilerCommandChange(); handleCompilerCommandChange();
} }
void GccToolChainConfigWidget::handlePlatformLinkerFlagsChange() void GccToolchainConfigWidget::handlePlatformLinkerFlagsChange()
{ {
QString str1 = m_platformLinkerFlagsLineEdit->text(); QString str1 = m_platformLinkerFlagsLineEdit->text();
QString str2 = ProcessArgs::joinArgs(splitString(str1)); QString str2 = ProcessArgs::joinArgs(splitString(str1));
@@ -1946,7 +1946,7 @@ void GccToolChainConfigWidget::handlePlatformLinkerFlagsChange()
// ClangToolChain // ClangToolChain
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
void GccToolChain::syncAutodetectedWithParentToolchains() void GccToolchain::syncAutodetectedWithParentToolchains()
{ {
if (!HostOsInfo::isWindowsHost() || typeId() != Constants::CLANG_TOOLCHAIN_TYPEID if (!HostOsInfo::isWindowsHost() || typeId() != Constants::CLANG_TOOLCHAIN_TYPEID
|| !isAutoDetected()) { || !isAutoDetected()) {
@@ -1961,7 +1961,7 @@ void GccToolChain::syncAutodetectedWithParentToolchains()
[id = id()] { [id = id()] {
if (Toolchain * const tc = ToolchainManager::findToolchain(id)) { if (Toolchain * const tc = ToolchainManager::findToolchain(id)) {
if (tc->typeId() == Constants::CLANG_TOOLCHAIN_TYPEID) if (tc->typeId() == Constants::CLANG_TOOLCHAIN_TYPEID)
static_cast<GccToolChain *>(tc)->syncAutodetectedWithParentToolchains(); static_cast<GccToolchain *>(tc)->syncAutodetectedWithParentToolchains();
} }
}); });
return; return;
@@ -1993,7 +1993,7 @@ void GccToolChain::syncAutodetectedWithParentToolchains()
}); });
} }
bool GccToolChain::matchesCompilerCommand(const FilePath &command) const bool GccToolchain::matchesCompilerCommand(const FilePath &command) const
{ {
if (m_subType == Clang) { if (m_subType == Clang) {
if (!m_resolvedCompilerCommand) { if (!m_resolvedCompilerCommand) {
@@ -2015,10 +2015,10 @@ bool GccToolChain::matchesCompilerCommand(const FilePath &command) const
return Toolchain::matchesCompilerCommand(command); return Toolchain::matchesCompilerCommand(command);
} }
QString GccToolChain::sysRoot() const QString GccToolchain::sysRoot() const
{ {
if (m_subType == Clang) { if (m_subType == Clang) {
if (const GccToolChain *parentTC = mingwToolChainFromId(m_parentToolChainId)) { if (const GccToolchain *parentTC = mingwToolChainFromId(m_parentToolChainId)) {
const FilePath mingwCompiler = parentTC->compilerCommand(); const FilePath mingwCompiler = parentTC->compilerCommand();
return mingwCompiler.parentDir().parentDir().toString(); return mingwCompiler.parentDir().parentDir().toString();
} }
@@ -2026,16 +2026,16 @@ QString GccToolChain::sysRoot() const
return {}; return {};
} }
void GccToolChainConfigWidget::updateParentToolChainComboBox() void GccToolchainConfigWidget::updateParentToolChainComboBox()
{ {
QTC_ASSERT(m_parentToolchainCombo, return); QTC_ASSERT(m_parentToolchainCombo, return);
auto *tc = static_cast<GccToolChain *>(toolChain()); auto *tc = static_cast<GccToolchain *>(toolChain());
QByteArray parentId = m_parentToolchainCombo->currentData().toByteArray(); QByteArray parentId = m_parentToolchainCombo->currentData().toByteArray();
if (tc->isAutoDetected() || m_parentToolchainCombo->count() == 0) if (tc->isAutoDetected() || m_parentToolchainCombo->count() == 0)
parentId = tc->m_parentToolChainId; parentId = tc->m_parentToolChainId;
const GccToolChain *parentTC = mingwToolChainFromId(parentId); const GccToolchain *parentTC = mingwToolChainFromId(parentId);
m_parentToolchainCombo->clear(); m_parentToolchainCombo->clear();
m_parentToolchainCombo->addItem(parentTC ? parentTC->displayName() : QString(), m_parentToolchainCombo->addItem(parentTC ? parentTC->displayName() : QString(),

16
src/plugins/projectexplorer/gcctoolchain.h
View File

@@ -16,23 +16,23 @@
namespace ProjectExplorer { namespace ProjectExplorer {
namespace Internal { namespace Internal {
class GccToolChainConfigWidget; class GccToolchainConfigWidget;
class GccToolchainFactory; class GccToolchainFactory;
const QStringList gccPredefinedMacrosOptions(Utils::Id languageId); const QStringList gccPredefinedMacrosOptions(Utils::Id languageId);
} }
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// GccToolChain // GccToolchain
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
class PROJECTEXPLORER_EXPORT GccToolChain : public Toolchain class PROJECTEXPLORER_EXPORT GccToolchain : public Toolchain
{ {
public: public:
enum SubType { RealGcc, Clang, MinGW, LinuxIcc }; enum SubType { RealGcc, Clang, MinGW, LinuxIcc };
GccToolChain(Utils::Id typeId, SubType subType = RealGcc); GccToolchain(Utils::Id typeId, SubType subType = RealGcc);
~GccToolChain() override; ~GccToolchain() override;
QString originalTargetTriple() const override; QString originalTargetTriple() const override;
Utils::FilePath installDir() const override; Utils::FilePath installDir() const override;
@@ -79,7 +79,7 @@ public:
Abis supportedAbis; Abis supportedAbis;
QString originalTargetTriple; QString originalTargetTriple;
}; };
GccToolChain *asGccToolChain() final { return this; } GccToolchain *asGccToolchain() final { return this; }
bool matchesCompilerCommand(const Utils::FilePath &command) const override; bool matchesCompilerCommand(const Utils::FilePath &command) const override;
@@ -102,7 +102,7 @@ protected:
virtual QString detectVersion() const; virtual QString detectVersion() const;
virtual Utils::FilePath detectInstallDir() const; virtual Utils::FilePath detectInstallDir() const;
// Reinterpret options for compiler drivers inheriting from GccToolChain (e.g qcc) to apply -Wp option // Reinterpret options for compiler drivers inheriting from GccToolchain (e.g qcc) to apply -Wp option
// that passes the initial options directly down to the gcc compiler // that passes the initial options directly down to the gcc compiler
using OptionsReinterpreter = std::function<QStringList(const QStringList &options)>; using OptionsReinterpreter = std::function<QStringList(const QStringList &options)>;
void setOptionsReinterpreter(const OptionsReinterpreter &optionsReinterpreter); void setOptionsReinterpreter(const OptionsReinterpreter &optionsReinterpreter);
@@ -148,7 +148,7 @@ private:
mutable QString m_version; mutable QString m_version;
mutable Utils::FilePath m_installDir; mutable Utils::FilePath m_installDir;
friend class Internal::GccToolChainConfigWidget; friend class Internal::GccToolchainConfigWidget;
friend class Internal::GccToolchainFactory; friend class Internal::GccToolchainFactory;
friend class ToolchainFactory; friend class ToolchainFactory;

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

@@ -40,7 +40,7 @@ QString languageId(Language l);
} // namespace Toolchain } // namespace Toolchain
} // namespace Deprecated } // namespace Deprecated
class GccToolChain; class GccToolchain;
class ToolchainConfigWidget; class ToolchainConfigWidget;
class Kit; class Kit;
@@ -161,7 +161,7 @@ public:
}; };
virtual int priority() const { return PriorityNormal; } virtual int priority() const { return PriorityNormal; }
virtual GccToolChain *asGccToolChain() { return nullptr; } virtual GccToolchain *asGccToolchain() { return nullptr; }
protected: protected:
explicit Toolchain(Utils::Id typeId); explicit Toolchain(Utils::Id typeId);

2
src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp
View File

@@ -336,7 +336,7 @@ QVariantMap DefaultPropertyProvider::autoGeneratedProperties(const ProjectExplor
} }
data.insert(QLatin1String(CPP_TOOLCHAINPATH), mainFilePath.absolutePath().toString()); data.insert(QLatin1String(CPP_TOOLCHAINPATH), mainFilePath.absolutePath().toString());
if (auto gcc = mainTc->asGccToolChain()) { if (auto gcc = mainTc->asGccToolchain()) {
QStringList compilerFlags = gcc->platformCodeGenFlags(); QStringList compilerFlags = gcc->platformCodeGenFlags();
filterCompilerLinkerFlags(targetAbi, compilerFlags); filterCompilerLinkerFlags(targetAbi, compilerFlags);
data.insert(QLatin1String(CPP_PLATFORMCOMMONCOMPILERFLAGS), compilerFlags); data.insert(QLatin1String(CPP_PLATFORMCOMMONCOMPILERFLAGS), compilerFlags);

10
src/plugins/qnx/qnxtoolchain.cpp
View File

@@ -98,7 +98,7 @@ static QStringList reinterpretOptions(const QStringList &args)
} }
QnxToolChain::QnxToolChain() QnxToolChain::QnxToolChain()
: GccToolChain(Constants::QNX_TOOLCHAIN_ID) : GccToolchain(Constants::QNX_TOOLCHAIN_ID)
{ {
setOptionsReinterpreter(&reinterpretOptions); setOptionsReinterpreter(&reinterpretOptions);
setTypeDisplayName(Tr::tr("QCC")); setTypeDisplayName(Tr::tr("QCC"));
@@ -128,7 +128,7 @@ void QnxToolChain::addToEnvironment(Environment &env) const
env.expandedValueForKey("QNX_CONFIGURATION_EXCLUSIVE").isEmpty()) env.expandedValueForKey("QNX_CONFIGURATION_EXCLUSIVE").isEmpty())
setQnxEnvironment(env, QnxUtils::qnxEnvironment(sdpPath())); setQnxEnvironment(env, QnxUtils::qnxEnvironment(sdpPath()));
GccToolChain::addToEnvironment(env); GccToolchain::addToEnvironment(env);
} }
QStringList QnxToolChain::suggestedMkspecList() const QStringList QnxToolChain::suggestedMkspecList() const
@@ -141,7 +141,7 @@ QStringList QnxToolChain::suggestedMkspecList() const
}; };
} }
GccToolChain::DetectedAbisResult QnxToolChain::detectSupportedAbis() const GccToolchain::DetectedAbisResult QnxToolChain::detectSupportedAbis() const
{ {
// "unknown-qnx-gnu"is needed to get the "--target=xxx" parameter sent code model, // "unknown-qnx-gnu"is needed to get the "--target=xxx" parameter sent code model,
// which gets translated as "x86_64-qnx-gnu", which gets Clang to happily parse // which gets translated as "x86_64-qnx-gnu", which gets Clang to happily parse
@@ -149,12 +149,12 @@ GccToolChain::DetectedAbisResult QnxToolChain::detectSupportedAbis() const
// //
// Without it on Windows Clang defaults to a MSVC mode, which breaks with // Without it on Windows Clang defaults to a MSVC mode, which breaks with
// the QNX code, which is mostly GNU based. // the QNX code, which is mostly GNU based.
return GccToolChain::DetectedAbisResult{detectTargetAbis(sdpPath()), "unknown-qnx-gnu"}; return GccToolchain::DetectedAbisResult{detectTargetAbis(sdpPath()), "unknown-qnx-gnu"};
} }
bool QnxToolChain::operator ==(const Toolchain &other) const bool QnxToolChain::operator ==(const Toolchain &other) const
{ {
if (!GccToolChain::operator ==(other)) if (!GccToolchain::operator ==(other))
return false; return false;
auto qnxTc = static_cast<const QnxToolChain *>(&other); auto qnxTc = static_cast<const QnxToolChain *>(&other);

2
src/plugins/qnx/qnxtoolchain.h
View File

@@ -7,7 +7,7 @@
namespace Qnx::Internal { namespace Qnx::Internal {
class QnxToolChain : public ProjectExplorer::GccToolChain class QnxToolChain : public ProjectExplorer::GccToolchain
{ {
public: public:
QnxToolChain(); QnxToolChain();

4
src/plugins/webassembly/webassemblytoolchain.cpp
View File

@@ -63,7 +63,7 @@ void WebAssemblyToolChain::addToEnvironment(Environment &env) const
} }
WebAssemblyToolChain::WebAssemblyToolChain() : WebAssemblyToolChain::WebAssemblyToolChain() :
GccToolChain(Constants::WEBASSEMBLY_TOOLCHAIN_TYPEID) GccToolchain(Constants::WEBASSEMBLY_TOOLCHAIN_TYPEID)
{ {
setSupportedAbis({toolChainAbi()}); setSupportedAbis({toolChainAbi()});
setTargetAbi(toolChainAbi()); setTargetAbi(toolChainAbi());
@@ -88,7 +88,7 @@ FilePath WebAssemblyToolChain::makeCommand(const Environment &environment) const
bool WebAssemblyToolChain::isValid() const bool WebAssemblyToolChain::isValid() const
{ {
return GccToolChain::isValid() return GccToolchain::isValid()
&& QVersionNumber::fromString(version()) >= minimumSupportedEmSdkVersion(); && QVersionNumber::fromString(version()) >= minimumSupportedEmSdkVersion();
} }

2
src/plugins/webassembly/webassemblytoolchain.h
View File

@@ -9,7 +9,7 @@
namespace WebAssembly::Internal { namespace WebAssembly::Internal {
class WebAssemblyToolChain final : public ProjectExplorer::GccToolChain class WebAssemblyToolChain final : public ProjectExplorer::GccToolchain
{ {
public: public:
WebAssemblyToolChain(); WebAssemblyToolChain();