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

PE: Make GccToolChainFactory::autoDetectToolchains static

Browse Source 
In preparation of running it in another thread.

Change-Id: I2cbac1bd45885416f8ee0dfdc95a4998e87d2f8e
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
This commit is contained in:
David Schulz
2023-09-15 11:54:47 +02:00
parent 1a64a179aa
commit 726cc7f5cd
4 changed files with 95 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1184,10 +1184,20 @@ Toolchains GccToolChainFactory::autoDetect(const ToolchainDetector &detector) co
&& tc->compilerCommand().fileName() != "c89-gcc" && tc->compilerCommand().fileName() != "c89-gcc"
&& tc->compilerCommand().fileName() != "c99-gcc"; && tc->compilerCommand().fileName() != "c99-gcc";
}; };
tcs.append(autoDetectToolchains("g++", DetectVariants::Yes, Constants::CXX_LANGUAGE_ID, tcs.append(autoDetectToolchains("g++",
Constants::GCC_TOOLCHAIN_TYPEID, detector, tcChecker)); DetectVariants::Yes,
tcs.append(autoDetectToolchains("gcc", DetectVariants::Yes, Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID,
Constants::GCC_TOOLCHAIN_TYPEID, detector, tcChecker)); Constants::GCC_TOOLCHAIN_TYPEID,
detector,
toolchainConstructor(),
tcChecker));
tcs.append(autoDetectToolchains("gcc",
DetectVariants::Yes,
Constants::C_LANGUAGE_ID,
Constants::GCC_TOOLCHAIN_TYPEID,
detector,
toolchainConstructor(),
tcChecker));
return tcs; return tcs;
} }
@@ -1207,7 +1217,7 @@ Toolchains GccToolChainFactory::detectForImport(const ToolChainDescription &tcd)
|| (fileName == "c++" && !resolvedSymlinksFileName.contains("clang"))); || (fileName == "c++" && !resolvedSymlinksFileName.contains("clang")));
if (isCCompiler || isCxxCompiler) { if (isCCompiler || isCxxCompiler) {
return autoDetectToolChain(tcd, [](const ToolChain *tc) { return autoDetectToolChain(tcd, toolchainConstructor(), [](const ToolChain *tc) {
return tc->targetAbi().osFlavor() != Abi::WindowsMSysFlavor; return tc->targetAbi().osFlavor() != Abi::WindowsMSysFlavor;
}); });
} }
@@ -1282,13 +1292,13 @@ static FilePaths findCompilerCandidates(const ToolchainDetector &detector,
return compilerPaths; return compilerPaths;
} }
Toolchains GccToolChainFactory::autoDetectToolchains( Toolchains GccToolChainFactory::autoDetectToolchains(const QString &compilerName,
const QString &compilerName, DetectVariants detectVariants,
DetectVariants detectVariants, const Id language,
const Id language, const Id requiredTypeId,
const Id requiredTypeId, const ToolchainDetector &detector,
const ToolchainDetector &detector, const ToolChainConstructor &constructor,
const ToolchainChecker &checker) const const ToolchainChecker &checker)
{ {
const FilePaths compilerPaths = const FilePaths compilerPaths =
findCompilerCandidates(detector, compilerName, detectVariants == DetectVariants::Yes); findCompilerCandidates(detector, compilerName, detectVariants == DetectVariants::Yes);
@@ -1331,7 +1341,7 @@ Toolchains GccToolChainFactory::autoDetectToolchains(
} }
if (!alreadyExists) { if (!alreadyExists) {
const QList<ToolChain *> newToolchains const QList<ToolChain *> newToolchains
= autoDetectToolChain({compilerPath, language}, checker); = autoDetectToolChain({compilerPath, language}, constructor, checker);
result << newToolchains; result << newToolchains;
existingCandidates << newToolchains; existingCandidates << newToolchains;
} }
@@ -1341,7 +1351,8 @@ Toolchains GccToolChainFactory::autoDetectToolchains(
} }
Toolchains GccToolChainFactory::autoDetectToolChain(const ToolChainDescription &tcd, Toolchains GccToolChainFactory::autoDetectToolChain(const ToolChainDescription &tcd,
const ToolchainChecker &checker) const const ToolChainConstructor &constructor,
const ToolchainChecker &checker)
{ {
Toolchains result; Toolchains result;
@@ -1361,7 +1372,7 @@ Toolchains GccToolChainFactory::autoDetectToolChain(const ToolChainDescription &
systemEnvironment, systemEnvironment,
macros); macros);
for (const Abi &abi : detectedAbis.supportedAbis) { for (const Abi &abi : detectedAbis.supportedAbis) {
std::unique_ptr<GccToolChain> tc(dynamic_cast<GccToolChain *>(create())); std::unique_ptr<GccToolChain> tc(dynamic_cast<GccToolChain *>(constructor()));
if (!tc) if (!tc)
return result; return result;
@@ -1704,18 +1715,30 @@ Toolchains ClangToolChainFactory::autoDetect(const ToolchainDetector &detector)
Toolchains tcs; Toolchains tcs;
Toolchains known = detector.alreadyKnown; Toolchains known = detector.alreadyKnown;
tcs.append(autoDetectToolchains("clang++", DetectVariants::Yes, Constants::CXX_LANGUAGE_ID, tcs.append(autoDetectToolchains("clang++",
Constants::CLANG_TOOLCHAIN_TYPEID, detector)); DetectVariants::Yes,
tcs.append(autoDetectToolchains("clang", DetectVariants::Yes, Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID,
Constants::CLANG_TOOLCHAIN_TYPEID, detector)); Constants::CLANG_TOOLCHAIN_TYPEID,
detector,
toolchainConstructor()));
tcs.append(autoDetectToolchains("clang",
DetectVariants::Yes,
Constants::C_LANGUAGE_ID,
Constants::CLANG_TOOLCHAIN_TYPEID,
detector,
toolchainConstructor()));
known.append(tcs); known.append(tcs);
const FilePath compilerPath = Core::ICore::clangExecutable(CLANG_BINDIR); const FilePath compilerPath = Core::ICore::clangExecutable(CLANG_BINDIR);
if (!compilerPath.isEmpty()) { if (!compilerPath.isEmpty()) {
const FilePath clang = compilerPath.parentDir().pathAppended("clang").withExecutableSuffix(); const FilePath clang = compilerPath.parentDir().pathAppended("clang").withExecutableSuffix();
tcs.append(autoDetectToolchains(clang.toString(), DetectVariants::No, tcs.append(
Constants::C_LANGUAGE_ID, Constants::CLANG_TOOLCHAIN_TYPEID, autoDetectToolchains(clang.toString(),
ToolchainDetector(known, detector.device, detector.searchPaths))); DetectVariants::No,
Constants::C_LANGUAGE_ID,
Constants::CLANG_TOOLCHAIN_TYPEID,
ToolchainDetector(known, detector.device, detector.searchPaths),
toolchainConstructor()));
} }
return tcs; return tcs;
@@ -1735,7 +1758,7 @@ Toolchains ClangToolChainFactory::detectForImport(const ToolChainDescription &tc
|| (fileName == "c++" && resolvedSymlinksFileName.contains("clang"))); || (fileName == "c++" && resolvedSymlinksFileName.contains("clang")));
if (isCCompiler || isCxxCompiler) { if (isCCompiler || isCxxCompiler) {
return autoDetectToolChain(tcd); return autoDetectToolChain(tcd, toolchainConstructor());
} }
return {}; return {};
} }
@@ -1901,11 +1924,20 @@ Toolchains MingwToolChainFactory::autoDetect(const ToolchainDetector &detector)
static const auto tcChecker = [](const ToolChain *tc) { static const auto tcChecker = [](const ToolChain *tc) {
return tc->targetAbi().osFlavor() == Abi::WindowsMSysFlavor; return tc->targetAbi().osFlavor() == Abi::WindowsMSysFlavor;
}; };
Toolchains result = autoDetectToolchains( Toolchains result = autoDetectToolchains("g++",
"g++", DetectVariants::Yes, Constants::CXX_LANGUAGE_ID, DetectVariants::Yes,
Constants::MINGW_TOOLCHAIN_TYPEID, detector, tcChecker); Constants::CXX_LANGUAGE_ID,
result += autoDetectToolchains("gcc", DetectVariants::Yes, Constants::C_LANGUAGE_ID, Constants::MINGW_TOOLCHAIN_TYPEID,
Constants::MINGW_TOOLCHAIN_TYPEID, detector, tcChecker); detector,
toolchainConstructor(),
tcChecker);
result += autoDetectToolchains("gcc",
DetectVariants::Yes,
Constants::C_LANGUAGE_ID,
Constants::MINGW_TOOLCHAIN_TYPEID,
detector,
toolchainConstructor(),
tcChecker);
return result; return result;
} }
@@ -1922,7 +1954,7 @@ Toolchains MingwToolChainFactory::detectForImport(const ToolChainDescription &tc
|| (fileName.startsWith("c++") || fileName.endsWith("c++"))); || (fileName.startsWith("c++") || fileName.endsWith("c++")));
if (cCompiler || cxxCompiler) { if (cCompiler || cxxCompiler) {
return autoDetectToolChain(tcd, [](const ToolChain *tc) { return autoDetectToolChain(tcd, toolchainConstructor(), [](const ToolChain *tc) {
return tc->targetAbi().osFlavor() == Abi::WindowsMSysFlavor; return tc->targetAbi().osFlavor() == Abi::WindowsMSysFlavor;
}); });
} }
@@ -1986,11 +2018,18 @@ LinuxIccToolChainFactory::LinuxIccToolChainFactory()
Toolchains LinuxIccToolChainFactory::autoDetect(const ToolchainDetector &detector) const Toolchains LinuxIccToolChainFactory::autoDetect(const ToolchainDetector &detector) const
{ {
Toolchains result Toolchains result = autoDetectToolchains("icpc",
= autoDetectToolchains("icpc", DetectVariants::No, Constants::CXX_LANGUAGE_ID, DetectVariants::No,
Constants::LINUXICC_TOOLCHAIN_TYPEID, detector); Constants::CXX_LANGUAGE_ID,
result += autoDetectToolchains("icc", DetectVariants::Yes, Constants::C_LANGUAGE_ID, Constants::LINUXICC_TOOLCHAIN_TYPEID,
Constants::LINUXICC_TOOLCHAIN_TYPEID, detector); detector,
toolchainConstructor());
result += autoDetectToolchains("icc",
DetectVariants::Yes,
Constants::C_LANGUAGE_ID,
Constants::LINUXICC_TOOLCHAIN_TYPEID,
detector,
toolchainConstructor());
return result; return result;
} }
@@ -1999,7 +2038,7 @@ Toolchains LinuxIccToolChainFactory::detectForImport(const ToolChainDescription
const QString fileName = tcd.compilerPath.completeBaseName(); const QString fileName = tcd.compilerPath.completeBaseName();
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"))) {
return autoDetectToolChain(tcd); return autoDetectToolChain(tcd, toolchainConstructor());
} }
return {}; return {};
} }

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

@@ -263,13 +263,16 @@ public:
protected: protected:
enum class DetectVariants { Yes, No }; enum class DetectVariants { Yes, No };
using ToolchainChecker = std::function<bool(const ToolChain *)>; using ToolchainChecker = std::function<bool(const ToolChain *)>;
Toolchains autoDetectToolchains( static Toolchains autoDetectToolchains(const QString &compilerName,
const QString &compilerName, DetectVariants detectVariants, const Utils::Id language, DetectVariants detectVariants,
const Utils::Id requiredTypeId, const ToolchainDetector &detector, const Utils::Id language,
const ToolchainChecker &checker = {}) const; const Utils::Id requiredTypeId,
Toolchains autoDetectToolChain( const ToolchainDetector &detector,
const ToolChainDescription &tcd, const ToolChainConstructor &constructor,
const ToolchainChecker &checker = {}) const; const ToolchainChecker &checker = {});
static Toolchains autoDetectToolChain(const ToolChainDescription &tcd,
const ToolChainConstructor &constructor,
const ToolchainChecker &checker = {});
}; };
class ClangToolChainFactory : public GccToolChainFactory class ClangToolChainFactory : public GccToolChainFactory

7
src/plugins/projectexplorer/toolchain.cpp
View File

@@ -672,11 +672,16 @@ void ToolChainFactory::setSupportsAllLanguages(bool supportsAllLanguages)
} }
void ToolChainFactory::setToolchainConstructor void ToolChainFactory::setToolchainConstructor
(const std::function<ToolChain *()> &toolchainContructor) (const ToolChainConstructor &toolchainContructor)
{ {
m_toolchainConstructor = toolchainContructor; m_toolchainConstructor = toolchainContructor;
} }
ToolChainFactory::ToolChainConstructor ToolChainFactory::toolchainConstructor() const
{
return m_toolchainConstructor;
}
void ToolChainFactory::setUserCreatable(bool userCreatable) void ToolChainFactory::setUserCreatable(bool userCreatable)
{ {
m_userCreatable = userCreatable; m_userCreatable = userCreatable;

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

@@ -260,7 +260,7 @@ public:
virtual Toolchains detectForImport(const ToolChainDescription &tcd) const; virtual Toolchains detectForImport(const ToolChainDescription &tcd) const;
virtual bool canCreate() const; virtual bool canCreate() const;
virtual ToolChain *create() const; ToolChain *create() const;
ToolChain *restore(const Utils::Store &data); ToolChain *restore(const Utils::Store &data);
@@ -279,7 +279,9 @@ protected:
void setSupportedToolChainType(const Utils::Id &supportedToolChainType); void setSupportedToolChainType(const Utils::Id &supportedToolChainType);
void setSupportedLanguages(const QList<Utils::Id> &supportedLanguages); void setSupportedLanguages(const QList<Utils::Id> &supportedLanguages);
void setSupportsAllLanguages(bool supportsAllLanguages); void setSupportsAllLanguages(bool supportsAllLanguages);
void setToolchainConstructor(const std::function<ToolChain *()> &constructor); using ToolChainConstructor = std::function<ToolChain *()>;
void setToolchainConstructor(const ToolChainConstructor &constructor);
ToolChainConstructor toolchainConstructor() const;
class Candidate { class Candidate {
public: public:
@@ -300,7 +302,7 @@ private:
QList<Utils::Id> m_supportedLanguages; QList<Utils::Id> m_supportedLanguages;
bool m_supportsAllLanguages = false; bool m_supportsAllLanguages = false;
bool m_userCreatable = false; bool m_userCreatable = false;
std::function<ToolChain *()> m_toolchainConstructor; ToolChainConstructor m_toolchainConstructor;
}; };
} // namespace ProjectExplorer } // namespace ProjectExplorer