summaryrefslogtreecommitdiff
path: root/src/plugins/projectexplorer/gcctoolchain.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/plugins/projectexplorer/gcctoolchain.cpp')
-rw-r--r--src/plugins/projectexplorer/gcctoolchain.cpp133
1 files changed, 73 insertions, 60 deletions
diff --git a/src/plugins/projectexplorer/gcctoolchain.cpp b/src/plugins/projectexplorer/gcctoolchain.cpp
index 25dfd23e29..ba9a5b9fb9 100644
--- a/src/plugins/projectexplorer/gcctoolchain.cpp
+++ b/src/plugins/projectexplorer/gcctoolchain.cpp
@@ -37,11 +37,9 @@
#include <utils/algorithm.h>
#include <utils/environment.h>
#include <utils/hostosinfo.h>
-#include <utils/synchronousprocess.h>
#include <utils/pathchooser.h>
#include <utils/qtcassert.h>
#include <utils/qtcprocess.h>
-#include <utils/synchronousprocess.h>
#include <QBuffer>
#include <QComboBox>
@@ -78,33 +76,32 @@ static const char supportedAbisKeyC[] = "ProjectExplorer.GccToolChain.SupportedA
static const char parentToolChainIdKeyC[] = "ProjectExplorer.ClangToolChain.ParentToolChainId";
static const char binaryRegexp[] = "(?:^|-|\\b)(?:gcc|g\\+\\+|clang(?:\\+\\+)?)(?:-([\\d.]+))?$";
-static QByteArray runGcc(const FilePath &gcc, const QStringList &arguments, const QStringList &env)
+static QByteArray runGcc(const FilePath &gcc, const QStringList &arguments, const Environment &env)
{
- if (gcc.isEmpty() || !gcc.toFileInfo().isExecutable())
+ if (!gcc.isExecutableFile())
return QByteArray();
SynchronousProcess cpp;
- QStringList environment(env);
- Utils::Environment::setupEnglishOutput(&environment);
+ Environment environment(env);
+ environment.setupEnglishOutput();
cpp.setEnvironment(environment);
cpp.setTimeoutS(10);
- CommandLine cmdLine(gcc, arguments);
- SynchronousProcessResponse response = cpp.runBlocking(cmdLine);
- if (response.result != SynchronousProcessResponse::Finished ||
- response.exitCode != 0) {
+ cpp.setCommand({gcc, arguments});
+ cpp.runBlocking();
+ if (cpp.result() != QtcProcess::Finished || cpp.exitCode() != 0) {
Core::MessageManager::writeFlashing({"Compiler feature detection failure!",
- response.exitMessage(cmdLine.toUserOutput(), 10),
- QString::fromUtf8(response.allRawOutput())});
+ cpp.exitMessage(),
+ QString::fromUtf8(cpp.allRawOutput())});
return QByteArray();
}
- return response.allOutput().toUtf8();
+ return cpp.allOutput().toUtf8();
}
static ProjectExplorer::Macros gccPredefinedMacros(const FilePath &gcc,
const QStringList &args,
- const QStringList &env)
+ const Environment &env)
{
QStringList arguments = args;
arguments << "-";
@@ -128,8 +125,9 @@ static ProjectExplorer::Macros gccPredefinedMacros(const FilePath &gcc,
return predefinedMacros;
}
-HeaderPaths GccToolChain::gccHeaderPaths(const FilePath &gcc, const QStringList &arguments,
- const QStringList &env)
+HeaderPaths GccToolChain::gccHeaderPaths(const FilePath &gcc,
+ const QStringList &arguments,
+ const Environment &env)
{
HeaderPaths builtInHeaderPaths;
QByteArray line;
@@ -211,9 +209,10 @@ static Abis guessGccAbi(const QString &m, const ProjectExplorer::Macros &macros)
}
-static GccToolChain::DetectedAbisResult guessGccAbi(const FilePath &path, const QStringList &env,
- const ProjectExplorer::Macros &macros,
- const QStringList &extraArgs = QStringList())
+static GccToolChain::DetectedAbisResult guessGccAbi(const FilePath &path,
+ const Environment &env,
+ const Macros &macros,
+ const QStringList &extraArgs = {})
{
if (path.isEmpty())
return GccToolChain::DetectedAbisResult();
@@ -230,7 +229,8 @@ static GccToolChain::DetectedAbisResult guessGccAbi(const FilePath &path, const
return GccToolChain::DetectedAbisResult(guessGccAbi(machine, macros), machine);
}
-static QString gccVersion(const FilePath &path, const QStringList &env,
+static QString gccVersion(const FilePath &path,
+ const Environment &env,
const QStringList &extraArgs)
{
QStringList arguments = extraArgs;
@@ -238,8 +238,9 @@ static QString gccVersion(const FilePath &path, const QStringList &env,
return QString::fromLocal8Bit(runGcc(path, arguments, env)).trimmed();
}
-static Utils::FilePath gccInstallDir(const FilePath &path, const QStringList &env,
- const QStringList &extraArgs = {})
+static FilePath gccInstallDir(const FilePath &path,
+ const Environment &env,
+ const QStringList &extraArgs = {})
{
QStringList arguments = extraArgs;
arguments << "-print-search-dirs";
@@ -254,7 +255,7 @@ static Utils::FilePath gccInstallDir(const FilePath &path, const QStringList &en
const QString line = QTextStream(&output).readLine();
if (!line.startsWith(prefix))
return {};
- return Utils::FilePath::fromString(QDir::cleanPath(line.mid(prefix.size())));
+ return FilePath::fromString(QDir::cleanPath(line.mid(prefix.size()))).onDevice(path);
}
// --------------------------------------------------------------------------
@@ -306,11 +307,11 @@ QString GccToolChain::defaultDisplayName() const
const Abi abi = targetAbi();
if (abi.architecture() == Abi::UnknownArchitecture || abi.wordWidth() == 0)
return type;
- return tr("%1 (%2, %3 %4 in %5)").arg(type,
+ return tr("%1 (%2, %3 %4 at %5)").arg(type,
ToolChainManager::displayNameOfLanguageId(language()),
Abi::toString(abi.architecture()),
Abi::toString(abi.wordWidth()),
- compilerCommand().parentDir().toUserOutput());
+ compilerCommand().toUserOutput());
}
LanguageExtensions GccToolChain::defaultLanguageExtensions() const
@@ -440,7 +441,7 @@ ToolChain::MacroInspectionRunner GccToolChain::createMacroInspectionRunner() con
const Macros macros = gccPredefinedMacros(findLocalCompiler(compilerCommand, env),
arguments,
- env.toStringList());
+ env);
const auto report = MacroInspectionReport{macros, languageVersion(lang, macros)};
macroCache->insert(arguments, report);
@@ -586,7 +587,7 @@ HeaderPaths GccToolChain::builtInHeaderPaths(const Utils::Environment &env,
HeaderPaths paths = gccHeaderPaths(findLocalCompiler(compilerCommand, env),
arguments,
- env.toStringList());
+ env);
extraHeaderPathsFunction(paths);
headerCache->insert(qMakePair(env, arguments), paths);
@@ -822,7 +823,7 @@ GccToolChain::DetectedAbisResult GccToolChain::detectSupportedAbis() const
addToEnvironment(env);
ProjectExplorer::Macros macros = createMacroInspectionRunner()({}).macros;
return guessGccAbi(findLocalCompiler(compilerCommand(), env),
- env.toStringList(),
+ env,
macros,
platformCodeGenFlags());
}
@@ -831,7 +832,7 @@ QString GccToolChain::detectVersion() const
{
Environment env = Environment::systemEnvironment();
addToEnvironment(env);
- return gccVersion(findLocalCompiler(compilerCommand(), env), env.toStringList(),
+ return gccVersion(findLocalCompiler(compilerCommand(), env), env,
filteredFlags(platformCodeGenFlags(), true));
}
@@ -839,7 +840,7 @@ Utils::FilePath GccToolChain::detectInstallDir() const
{
Environment env = Environment::systemEnvironment();
addToEnvironment(env);
- return gccInstallDir(findLocalCompiler(compilerCommand(), env), env.toStringList(),
+ return gccInstallDir(findLocalCompiler(compilerCommand(), env), env,
filteredFlags(platformCodeGenFlags(), true));
}
@@ -998,7 +999,8 @@ GccToolChainFactory::GccToolChainFactory()
setUserCreatable(true);
}
-QList<ToolChain *> GccToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown)
+QList<ToolChain *> GccToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown,
+ const IDevice::Ptr &device)
{
// GCC is almost never what you want on macOS, but it is by default found in /usr/bin
if (HostOsInfo::isMacHost())
@@ -1010,9 +1012,11 @@ QList<ToolChain *> GccToolChainFactory::autoDetect(const QList<ToolChain *> &alr
&& tc->compilerCommand().fileName() != "c99-gcc";
};
tcs.append(autoDetectToolchains("g++", DetectVariants::Yes, Constants::CXX_LANGUAGE_ID,
- Constants::GCC_TOOLCHAIN_TYPEID, alreadyKnown, tcChecker));
+ Constants::GCC_TOOLCHAIN_TYPEID, alreadyKnown,
+ device, tcChecker));
tcs.append(autoDetectToolchains("gcc", DetectVariants::Yes, Constants::C_LANGUAGE_ID,
- Constants::GCC_TOOLCHAIN_TYPEID, alreadyKnown, tcChecker));
+ Constants::GCC_TOOLCHAIN_TYPEID, alreadyKnown,
+ device, tcChecker));
return tcs;
}
@@ -1032,10 +1036,16 @@ QList<ToolChain *> GccToolChainFactory::detectForImport(const ToolChainDescripti
}
QList<ToolChain *> GccToolChainFactory::autoDetectToolchains(
- const QString &compilerName, DetectVariants detectVariants, Utils::Id language,
- const Utils::Id requiredTypeId, const QList<ToolChain *> &alreadyKnown,
+ const QString &compilerName,
+ DetectVariants detectVariants,
+ const Id language,
+ const Id requiredTypeId,
+ const QList<ToolChain *> &alreadyKnown,
+ const IDevice::Ptr &device,
const ToolchainChecker &checker)
{
+ Q_UNUSED(device)
+
FilePaths compilerPaths;
QFileInfo fi(compilerName);
if (fi.isAbsolute()) {
@@ -1123,8 +1133,8 @@ QList<ToolChain *> GccToolChainFactory::autoDetectToolchains(
}
}
if (!alreadyExists) {
- const QList<ToolChain *> newToolchains = autoDetectToolChain({compilerPath, language},
- checker);
+ const QList<ToolChain *> newToolchains
+ = autoDetectToolChain({compilerPath, language}, checker);
result << newToolchains;
existingCandidates << newToolchains;
}
@@ -1143,14 +1153,14 @@ QList<ToolChain *> GccToolChainFactory::autoDetectToolChain(const ToolChainDescr
const FilePath localCompilerPath = findLocalCompiler(tcd.compilerPath, systemEnvironment);
Macros macros
= gccPredefinedMacros(localCompilerPath, gccPredefinedMacrosOptions(tcd.language),
- systemEnvironment.toStringList());
+ systemEnvironment);
if (macros.isEmpty())
return result;
const GccToolChain::DetectedAbisResult detectedAbis = guessGccAbi(localCompilerPath,
- systemEnvironment.toStringList(),
+ systemEnvironment,
macros);
const Utils::FilePath installDir = gccInstallDir(localCompilerPath,
- systemEnvironment.toStringList());
+ systemEnvironment);
for (const Abi &abi : detectedAbis.supportedAbis) {
std::unique_ptr<GccToolChain> tc(dynamic_cast<GccToolChain *>(create()));
@@ -1192,10 +1202,10 @@ GccToolChainConfigWidget::GccToolChainConfigWidget(GccToolChain *tc) :
m_compilerCommand->setHistoryCompleter("PE.Gcc.Command.History");
m_mainLayout->addRow(tr("&Compiler path:"), m_compilerCommand);
m_platformCodeGenFlagsLineEdit = new QLineEdit(this);
- m_platformCodeGenFlagsLineEdit->setText(QtcProcess::joinArgs(tc->platformCodeGenFlags()));
+ m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->platformCodeGenFlags()));
m_mainLayout->addRow(tr("Platform codegen flags:"), m_platformCodeGenFlagsLineEdit);
m_platformLinkerFlagsLineEdit = new QLineEdit(this);
- m_platformLinkerFlagsLineEdit->setText(QtcProcess::joinArgs(tc->platformLinkerFlags()));
+ m_platformLinkerFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->platformLinkerFlags()));
m_mainLayout->addRow(tr("Platform linker flags:"), m_platformLinkerFlagsLineEdit);
m_mainLayout->addRow(tr("&ABI:"), m_abiWidget);
@@ -1248,8 +1258,8 @@ void GccToolChainConfigWidget::setFromToolchain()
QSignalBlocker blocker(this);
auto tc = static_cast<GccToolChain *>(toolChain());
m_compilerCommand->setFilePath(tc->compilerCommand());
- m_platformCodeGenFlagsLineEdit->setText(QtcProcess::joinArgs(tc->platformCodeGenFlags()));
- m_platformLinkerFlagsLineEdit->setText(QtcProcess::joinArgs(tc->platformLinkerFlags()));
+ m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->platformCodeGenFlags()));
+ m_platformLinkerFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->platformLinkerFlags()));
if (m_abiWidget) {
m_abiWidget->setAbis(tc->supportedAbis(), tc->targetAbi());
if (!m_isReadOnly && !m_compilerCommand->filePath().toString().isEmpty())
@@ -1263,9 +1273,9 @@ bool GccToolChainConfigWidget::isDirtyImpl() const
Q_ASSERT(tc);
return m_compilerCommand->filePath() != tc->compilerCommand()
|| m_platformCodeGenFlagsLineEdit->text()
- != QtcProcess::joinArgs(tc->platformCodeGenFlags())
+ != ProcessArgs::joinArgs(tc->platformCodeGenFlags())
|| m_platformLinkerFlagsLineEdit->text()
- != QtcProcess::joinArgs(tc->platformLinkerFlags())
+ != ProcessArgs::joinArgs(tc->platformLinkerFlags())
|| (m_abiWidget && m_abiWidget->currentAbi() != tc->targetAbi());
}
@@ -1300,8 +1310,8 @@ void GccToolChainConfigWidget::handleCompilerCommandChange()
QStringList args = gccPredefinedMacrosOptions(Constants::CXX_LANGUAGE_ID)
+ splitString(m_platformCodeGenFlagsLineEdit->text());
const FilePath localCompilerPath = findLocalCompiler(path, env);
- m_macros = gccPredefinedMacros(localCompilerPath, args, env.toStringList());
- abiList = guessGccAbi(localCompilerPath, env.toStringList(), m_macros,
+ m_macros = gccPredefinedMacros(localCompilerPath, args, env);
+ abiList = guessGccAbi(localCompilerPath, env, m_macros,
splitString(m_platformCodeGenFlagsLineEdit->text())).supportedAbis;
}
m_abiWidget->setEnabled(haveCompiler);
@@ -1318,7 +1328,7 @@ void GccToolChainConfigWidget::handleCompilerCommandChange()
void GccToolChainConfigWidget::handlePlatformCodeGenFlagsChange()
{
QString str1 = m_platformCodeGenFlagsLineEdit->text();
- QString str2 = QtcProcess::joinArgs(splitString(str1));
+ QString str2 = ProcessArgs::joinArgs(splitString(str1));
if (str1 != str2)
m_platformCodeGenFlagsLineEdit->setText(str2);
else
@@ -1328,7 +1338,7 @@ void GccToolChainConfigWidget::handlePlatformCodeGenFlagsChange()
void GccToolChainConfigWidget::handlePlatformLinkerFlagsChange()
{
QString str1 = m_platformLinkerFlagsLineEdit->text();
- QString str2 = QtcProcess::joinArgs(splitString(str1));
+ QString str2 = ProcessArgs::joinArgs(splitString(str1));
if (str1 != str2)
m_platformLinkerFlagsLineEdit->setText(str2);
else
@@ -1591,15 +1601,16 @@ ClangToolChainFactory::ClangToolChainFactory()
setToolchainConstructor([] { return new ClangToolChain; });
}
-QList<ToolChain *> ClangToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown)
+QList<ToolChain *> ClangToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown,
+ const IDevice::Ptr &device)
{
QList<ToolChain *> tcs;
QList<ToolChain *> known = alreadyKnown;
tcs.append(autoDetectToolchains("clang++", DetectVariants::Yes, Constants::CXX_LANGUAGE_ID,
- Constants::CLANG_TOOLCHAIN_TYPEID, alreadyKnown));
+ Constants::CLANG_TOOLCHAIN_TYPEID, alreadyKnown, device));
tcs.append(autoDetectToolchains("clang", DetectVariants::Yes, Constants::C_LANGUAGE_ID,
- Constants::CLANG_TOOLCHAIN_TYPEID, alreadyKnown));
+ Constants::CLANG_TOOLCHAIN_TYPEID, alreadyKnown, device));
known.append(tcs);
const FilePath compilerPath = FilePath::fromString(Core::ICore::clangExecutable(CLANG_BINDIR));
@@ -1608,7 +1619,7 @@ QList<ToolChain *> ClangToolChainFactory::autoDetect(const QList<ToolChain *> &a
HostOsInfo::withExecutableSuffix("clang"));
tcs.append(autoDetectToolchains(clang.toString(), DetectVariants::No,
Constants::C_LANGUAGE_ID, Constants::CLANG_TOOLCHAIN_TYPEID,
- tcs));
+ tcs, device));
}
return tcs;
@@ -1779,16 +1790,17 @@ MingwToolChainFactory::MingwToolChainFactory()
setToolchainConstructor([] { return new MingwToolChain; });
}
-QList<ToolChain *> MingwToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown)
+QList<ToolChain *> MingwToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown,
+ const IDevice::Ptr &device)
{
static const auto tcChecker = [](const ToolChain *tc) {
return tc->targetAbi().osFlavor() == Abi::WindowsMSysFlavor;
};
QList<ToolChain *> result = autoDetectToolchains(
"g++", DetectVariants::Yes, Constants::CXX_LANGUAGE_ID,
- Constants::MINGW_TOOLCHAIN_TYPEID, alreadyKnown, tcChecker);
+ Constants::MINGW_TOOLCHAIN_TYPEID, alreadyKnown, device, tcChecker);
result += autoDetectToolchains("gcc", DetectVariants::Yes, Constants::C_LANGUAGE_ID,
- Constants::MINGW_TOOLCHAIN_TYPEID, alreadyKnown, tcChecker);
+ Constants::MINGW_TOOLCHAIN_TYPEID, alreadyKnown, device, tcChecker);
return result;
}
@@ -1860,13 +1872,14 @@ LinuxIccToolChainFactory::LinuxIccToolChainFactory()
setToolchainConstructor([] { return new LinuxIccToolChain; });
}
-QList<ToolChain *> LinuxIccToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown)
+QList<ToolChain *> LinuxIccToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown,
+ const IDevice::Ptr &device)
{
QList<ToolChain *> result
= autoDetectToolchains("icpc", DetectVariants::No, Constants::CXX_LANGUAGE_ID,
- Constants::LINUXICC_TOOLCHAIN_TYPEID, alreadyKnown);
+ Constants::LINUXICC_TOOLCHAIN_TYPEID, alreadyKnown, device);
result += autoDetectToolchains("icc", DetectVariants::Yes, Constants::C_LANGUAGE_ID,
- Constants::LINUXICC_TOOLCHAIN_TYPEID, alreadyKnown);
+ Constants::LINUXICC_TOOLCHAIN_TYPEID, alreadyKnown, device);
return result;
}
View Lorry Controller Status