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

ProjectExplorer: Apply clang-format to msvctoolchain files

Browse Source 
Change-Id: I92d7f216a514ad855c9bee2119f29617ecb9f52d
Reviewed-by: David Schulz <david.schulz@qt.io>
This commit is contained in:
Ivan Donchevskii
2019-01-07 15:58:49 +01:00
parent 773a6e1b42
commit e4f488cb5c
2 changed files with 364 additions and 319 deletions
Download Patch File Download Diff File Expand all files Collapse all files

383
src/plugins/projectexplorer/msvctoolchain.cpp
View File

@@ -60,10 +60,10 @@
#include <QFormLayout>
#define KEY_ROOT "ProjectExplorer.MsvcToolChain."
static const char varsBatKeyC[] = KEY_ROOT"VarsBat";
static const char varsBatArgKeyC[] = KEY_ROOT"VarsBatArg";
static const char supportedAbiKeyC[] = KEY_ROOT"SupportedAbi";
static const char environModsKeyC[] = KEY_ROOT"environmentModifications";
static const char varsBatKeyC[] = KEY_ROOT "VarsBat";
static const char varsBatArgKeyC[] = KEY_ROOT "VarsBatArg";
static const char supportedAbiKeyC[] = KEY_ROOT "SupportedAbi";
static const char environModsKeyC[] = KEY_ROOT "environmentModifications";
enum { debug = 0 };
@@ -84,16 +84,16 @@ static QThreadPool *envModThreadPool()
return pool;
}
struct MsvcPlatform {
struct MsvcPlatform
{
MsvcToolChain::Platform platform;
const char *name;
const char *prefix; // VS up until 14.0 (MSVC2015)
const char *bat;
};
const MsvcPlatform platforms[] =
{
{MsvcToolChain::x86, "x86", "/bin", "vcvars32.bat"},
const MsvcPlatform platforms[]
= {{MsvcToolChain::x86, "x86", "/bin", "vcvars32.bat"},
{MsvcToolChain::amd64, "amd64", "/bin/amd64", "vcvars64.bat"},
{MsvcToolChain::x86_amd64, "x86_amd64", "/bin/x86_amd64", "vcvarsx86_amd64.bat"},
{MsvcToolChain::ia64, "ia64", "/bin/ia64", "vcvars64.bat"},
@@ -101,8 +101,7 @@ const MsvcPlatform platforms[] =
{MsvcToolChain::arm, "arm", "/bin/arm", "vcvarsarm.bat"},
{MsvcToolChain::x86_arm, "x86_arm", "/bin/x86_arm", "vcvarsx86_arm.bat"},
{MsvcToolChain::amd64_arm, "amd64_arm", "/bin/amd64_arm", "vcvarsamd64_arm.bat"},
{MsvcToolChain::amd64_x86, "amd64_x86", "/bin/amd64_x86", "vcvarsamd64_x86.bat"}
};
{MsvcToolChain::amd64_x86, "amd64_x86", "/bin/amd64_x86", "vcvarsamd64_x86.bat"}};
static QList<const MsvcToolChain *> g_availableMsvcToolchains;
@@ -164,10 +163,10 @@ QDebug operator<<(QDebug d, const VisualStudioInstallation &i)
QDebugStateSaver saver(d);
d.noquote();
d.nospace();
d << "VisualStudioInstallation(\"" << i.vsName << "\", v=" << i.version
<< ", path=\"" << QDir::toNativeSeparators(i.path)
<< "\", vcVarsPath=\"" << QDir::toNativeSeparators(i.vcVarsPath)
<< "\", vcVarsAll=\"" << QDir::toNativeSeparators(i.vcVarsAll) << "\")";
d << "VisualStudioInstallation(\"" << i.vsName << "\", v=" << i.version << ", path=\""
<< QDir::toNativeSeparators(i.path) << "\", vcVarsPath=\""
<< QDir::toNativeSeparators(i.vcVarsPath) << "\", vcVarsAll=\""
<< QDir::toNativeSeparators(i.vcVarsAll) << "\")";
return d;
}
@@ -182,8 +181,7 @@ static QString windowsProgramFilesDir()
}
static Utils::optional<VisualStudioInstallation> installationFromPathAndVersion(
const QString &installationPath,
const QVersionNumber &version)
const QString &installationPath, const QVersionNumber &version)
{
QString vcVarsPath = QDir::fromNativeSeparators(installationPath);
if (!vcVarsPath.endsWith('/'))
@@ -196,8 +194,7 @@ static Utils::optional<VisualStudioInstallation> installationFromPathAndVersion(
const QString vcVarsAllPath = vcVarsPath + QStringLiteral("/vcvarsall.bat");
if (!QFileInfo(vcVarsAllPath).isFile()) {
qWarning().noquote() << "Unable to find MSVC setup script "
<< QDir::toNativeSeparators(vcVarsPath) << " in version "
<< version;
<< QDir::toNativeSeparators(vcVarsPath) << " in version " << version;
return Utils::nullopt;
}
@@ -238,8 +235,8 @@ static QVector<VisualStudioInstallation> detectVisualStudioFromVsWhere(const QSt
Utils::SynchronousProcess vsWhereProcess;
const int timeoutS = 5;
vsWhereProcess.setTimeoutS(timeoutS);
const QStringList arguments { "-products", "*", "-prerelease", "-legacy", "-format", "json",
"-utf8"};
const QStringList
arguments{"-products", "*", "-prerelease", "-legacy", "-format", "json", "-utf8"};
Utils::SynchronousProcessResponse response = vsWhereProcess.runBlocking(vswhere, arguments);
switch (response.result) {
case Utils::SynchronousProcessResponse::Finished:
@@ -248,12 +245,13 @@ static QVector<VisualStudioInstallation> detectVisualStudioFromVsWhere(const QSt
qWarning().noquote() << QDir::toNativeSeparators(vswhere) << "could not be started.";
return installations;
case Utils::SynchronousProcessResponse::FinishedError:
qWarning().noquote().nospace() << QDir::toNativeSeparators(vswhere) << " finished with exit "
"code " << response.exitCode << ".";
qWarning().noquote().nospace() << QDir::toNativeSeparators(vswhere)
<< " finished with exit code "
<< response.exitCode << ".";
return installations;
case Utils::SynchronousProcessResponse::TerminatedAbnormally:
qWarning().noquote().nospace() << QDir::toNativeSeparators(vswhere) << " crashed. Exit code: "
<< response.exitCode;
qWarning().noquote().nospace()
<< QDir::toNativeSeparators(vswhere) << " crashed. Exit code: " << response.exitCode;
return installations;
case Utils::SynchronousProcessResponse::Hang:
qWarning().noquote() << QDir::toNativeSeparators(vswhere) << "did not finish in" << timeoutS
@@ -308,9 +306,11 @@ static QVector<VisualStudioInstallation> detectVisualStudioFromRegistry()
{
QVector<VisualStudioInstallation> result;
#ifdef Q_OS_WIN64
const QString keyRoot = QStringLiteral("HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\SxS\\");
const QString keyRoot = QStringLiteral(
"HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\SxS\\");
#else
const QString keyRoot = QStringLiteral("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\SxS\\");
const QString keyRoot = QStringLiteral(
"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\SxS\\");
#endif
QSettings vsRegistry(keyRoot + QStringLiteral("VS7"), QSettings::NativeFormat);
QScopedPointer<QSettings> vcRegistry;
@@ -339,8 +339,8 @@ static QVector<VisualStudioInstallation> detectVisualStudio()
const QString vswhere = windowsProgramFilesDir()
+ "/Microsoft Visual Studio/Installer/vswhere.exe";
if (QFileInfo::exists(vswhere)) {
const QVector<VisualStudioInstallation> installations
= detectVisualStudioFromVsWhere(vswhere);
const QVector<VisualStudioInstallation> installations = detectVisualStudioFromVsWhere(
vswhere);
if (!installations.isEmpty())
return installations;
}
@@ -348,14 +348,15 @@ static QVector<VisualStudioInstallation> detectVisualStudio()
return detectVisualStudioFromRegistry();
}
static Abi findAbiOfMsvc(MsvcToolChain::Type type, MsvcToolChain::Platform platform, const QString &version)
static Abi findAbiOfMsvc(MsvcToolChain::Type type,
MsvcToolChain::Platform platform,
const QString &version)
{
Abi::Architecture arch = Abi::X86Architecture;
Abi::OSFlavor flavor = Abi::UnknownFlavor;
int wordWidth = 64;
switch (platform)
{
switch (platform) {
case MsvcToolChain::x86:
case MsvcToolChain::amd64_x86:
wordWidth = 32;
@@ -399,7 +400,8 @@ static Abi findAbiOfMsvc(MsvcToolChain::Type type, MsvcToolChain::Platform platf
const Abi result = Abi(arch, Abi::WindowsOS, flavor, Abi::PEFormat, wordWidth);
if (!result.isValid())
qWarning("Unable to completely determine the ABI of MSVC version %s (%s).",
qPrintable(version), qPrintable(result.toString()));
qPrintable(version),
qPrintable(result.toString()));
return result;
}
@@ -427,8 +429,7 @@ static QByteArray msvcCompilationDefine(const char *def)
static QByteArray msvcCompilationFile()
{
static const char* macros[] = {
"_ATL_VER",
static const char *macros[] = {"_ATL_VER",
"__ATOM__",
"__AVX__",
"__AVX2__",
@@ -494,8 +495,7 @@ static QByteArray msvcCompilationFile()
"_WIN64",
"_WINRT_DLL",
"_Wp64",
nullptr
};
nullptr};
QByteArray file = "#define __PPOUT__(x) V##x=x\n\n";
for (int i = 0; macros[i] != nullptr; ++i)
file += msvcCompilationDefine(macros[i]);
@@ -571,13 +571,15 @@ Macros MsvcToolChain::msvcPredefinedMacros(const QStringList &cxxflags,
const QString define = arg.mid(2);
predefinedMacros.append(Macro::fromKeyValue(define));
} else if (arg.startsWith(QLatin1String("/U"))) {
predefinedMacros.append({arg.mid(2).toLocal8Bit(), ProjectExplorer::MacroType::Undefine});
predefinedMacros.append(
{arg.mid(2).toLocal8Bit(), ProjectExplorer::MacroType::Undefine});
} else {
toProcess.append(arg);
}
}
Utils::TempFileSaver saver(Utils::TemporaryDirectory::masterDirectoryPath() + "/envtestXXXXXX.cpp");
Utils::TempFileSaver saver(Utils::TemporaryDirectory::masterDirectoryPath()
+ "/envtestXXXXXX.cpp");
saver.write(msvcCompilationFile());
if (!saver.finalize()) {
qWarning("%s: %s", Q_FUNC_INFO, qPrintable(saver.errorString()));
@@ -597,8 +599,7 @@ Macros MsvcToolChain::msvcPredefinedMacros(const QStringList &cxxflags,
arguments << QLatin1String("/TC");
arguments << toProcess << QLatin1String("/EP") << QDir::toNativeSeparators(saver.fileName());
Utils::SynchronousProcessResponse response = cpp.runBlocking(binary.toString(), arguments);
if (response.result != Utils::SynchronousProcessResponse::Finished ||
response.exitCode != 0)
if (response.result != Utils::SynchronousProcessResponse::Finished || response.exitCode != 0)
return predefinedMacros;
const QStringList output = Utils::filtered(response.stdOut().split('\n'),
@@ -664,7 +665,7 @@ LanguageVersion MsvcToolChain::msvcLanguageVersion(const QStringList & /*cxxflag
static QString winExpandDelayedEnvReferences(QString in, const Utils::Environment &env)
{
const QChar exclamationMark = QLatin1Char('!');
for (int pos = 0; pos < in.size(); ) {
for (int pos = 0; pos < in.size();) {
// Replace "!REF!" by its value in process environment
pos = in.indexOf(exclamationMark, pos);
if (pos == -1)
@@ -682,16 +683,18 @@ static QString winExpandDelayedEnvReferences(QString in, const Utils::Environmen
void MsvcToolChain::environmentModifications(
QFutureInterface<MsvcToolChain::GenerateEnvResult> &future,
QString vcvarsBat, QString varsBatArg)
QString vcvarsBat,
QString varsBatArg)
{
const Utils::Environment inEnv = Utils::Environment::systemEnvironment();
Utils::Environment outEnv;
QMap<QString, QString> envPairs;
QList<Utils::EnvironmentItem> diff;
Utils::optional<QString> error = generateEnvironmentSettings(inEnv, vcvarsBat,
varsBatArg, envPairs);
Utils::optional<QString> error = generateEnvironmentSettings(inEnv,
vcvarsBat,
varsBatArg,
envPairs);
if (!error) {
// Now loop through and process them
for (auto envIter = envPairs.cbegin(), end = envPairs.cend(); envIter != end; ++envIter) {
const QString expandedValue = winExpandDelayedEnvReferences(envIter.value(), inEnv);
@@ -744,7 +747,7 @@ void MsvcToolChain::updateEnvironmentModifications(QList<Utils::EnvironmentItem>
}
}
Utils::Environment MsvcToolChain::readEnvironmentSetting(const Utils::Environment& env) const
Utils::Environment MsvcToolChain::readEnvironmentSetting(const Utils::Environment &env) const
{
Utils::Environment resultEnv = env;
if (m_environmentModifications.isEmpty()) {
@@ -769,11 +772,14 @@ Utils::Environment MsvcToolChain::readEnvironmentSetting(const Utils::Environmen
// MsvcToolChain
// --------------------------------------------------------------------------
MsvcToolChain::MsvcToolChain(const QString &name, const Abi &abi,
const QString &varsBat, const QString &varsBatArg, Core::Id l,
Detection d) :
MsvcToolChain(Constants::MSVC_TOOLCHAIN_TYPEID, name, abi, varsBat, varsBatArg, l, d)
{ }
MsvcToolChain::MsvcToolChain(const QString &name,
const Abi &abi,
const QString &varsBat,
const QString &varsBatArg,
Core::Id l,
Detection d)
: MsvcToolChain(Constants::MSVC_TOOLCHAIN_TYPEID, name, abi, varsBat, varsBatArg, l, d)
{}
MsvcToolChain::MsvcToolChain(const MsvcToolChain &other)
: ToolChain(other)
@@ -804,8 +810,12 @@ MsvcToolChain::MsvcToolChain(const MsvcToolChain &other)
setDisplayName(other.displayName());
}
MsvcToolChain::MsvcToolChain(Core::Id typeId, const QString &name, const Abi &abi,
const QString &varsBat, const QString &varsBatArg, Core::Id l,
MsvcToolChain::MsvcToolChain(Core::Id typeId,
const QString &name,
const Abi &abi,
const QString &varsBat,
const QString &varsBatArg,
Core::Id l,
Detection d)
: ToolChain(typeId, d)
, m_predefinedMacrosCache(std::make_shared<Cache<MacroInspectionReport, 64>>())
@@ -818,7 +828,8 @@ MsvcToolChain::MsvcToolChain(Core::Id typeId, const QString &name, const Abi &ab
setLanguage(l);
initEnvModWatcher(Utils::runAsync(envModThreadPool(),
&MsvcToolChain::environmentModifications,
varsBat, varsBatArg));
varsBat,
varsBatArg));
Q_ASSERT(!name.isEmpty());
@@ -829,7 +840,7 @@ MsvcToolChain::MsvcToolChain(Core::Id typeId)
: ToolChain(typeId, ManualDetection)
, m_predefinedMacrosCache(std::make_shared<Cache<MacroInspectionReport, 64>>())
, m_lastEnvironment(Utils::Environment::systemEnvironment())
{ }
{}
void MsvcToolChain::inferWarningsForLevel(int warningLevel, WarningFlags &flags)
{
@@ -837,12 +848,14 @@ void MsvcToolChain::inferWarningsForLevel(int warningLevel, WarningFlags &flags)
flags = flags & WarningFlags::AsErrors;
if (warningLevel >= 1)
flags |= WarningFlags(WarningFlags::Default | WarningFlags::IgnoredQualfiers | WarningFlags::HiddenLocals | WarningFlags::UnknownPragma);
flags |= WarningFlags(WarningFlags::Default | WarningFlags::IgnoredQualfiers
| WarningFlags::HiddenLocals | WarningFlags::UnknownPragma);
if (warningLevel >= 2)
flags |= WarningFlags::All;
if (warningLevel >= 3) {
flags |= WarningFlags(WarningFlags::Extra | WarningFlags::NonVirtualDestructor | WarningFlags::SignedComparison
| WarningFlags::UnusedLocals | WarningFlags::Deprecated);
flags |= WarningFlags(WarningFlags::Extra | WarningFlags::NonVirtualDestructor
| WarningFlags::SignedComparison | WarningFlags::UnusedLocals
| WarningFlags::Deprecated);
}
if (warningLevel >= 4)
flags |= WarningFlags::UnusedParams;
@@ -853,8 +866,9 @@ void MsvcToolChain::toolChainUpdated()
m_predefinedMacrosCache->invalidate();
}
MsvcToolChain::MsvcToolChain() : MsvcToolChain(Constants::MSVC_TOOLCHAIN_TYPEID)
{ }
MsvcToolChain::MsvcToolChain()
: MsvcToolChain(Constants::MSVC_TOOLCHAIN_TYPEID)
{}
MsvcToolChain::~MsvcToolChain()
{
@@ -876,8 +890,7 @@ bool MsvcToolChain::isValid() const
QString MsvcToolChain::originalTargetTriple() const
{
return m_abi.wordWidth() == 64
? QLatin1String("x86_64-pc-windows-msvc")
return m_abi.wordWidth() == 64 ? QLatin1String("x86_64-pc-windows-msvc")
: QLatin1String("i686-pc-windows-msvc");
}
@@ -961,12 +974,12 @@ bool MsvcToolChain::fromMap(const QVariantMap &data)
initEnvModWatcher(Utils::runAsync(envModThreadPool(),
&MsvcToolChain::environmentModifications,
m_vcvarsBat, m_varsBatArg));
m_vcvarsBat,
m_varsBatArg));
return !m_vcvarsBat.isEmpty() && m_abi.isValid();
}
std::unique_ptr<ToolChainConfigWidget> MsvcToolChain::createConfigurationWidget()
{
return std::make_unique<MsvcToolChainConfigWidget>(this);
@@ -1046,16 +1059,18 @@ WarningFlags MsvcToolChain::warningFlags(const QStringList &cflags) const
if (!flag.isEmpty() && flag[0] == QLatin1Char('-'))
flag[0] = QLatin1Char('/');
if (flag == QLatin1String("/WX"))
if (flag == QLatin1String("/WX")) {
flags |= WarningFlags::AsErrors;
else if (flag == QLatin1String("/W0") || flag == QLatin1String("/w"))
} else if (flag == QLatin1String("/W0") || flag == QLatin1String("/w")) {
inferWarningsForLevel(0, flags);
else if (flag == QLatin1String("/W1"))
} else if (flag == QLatin1String("/W1")) {
inferWarningsForLevel(1, flags);
else if (flag == QLatin1String("/W2"))
} else if (flag == QLatin1String("/W2")) {
inferWarningsForLevel(2, flags);
else if (flag == QLatin1String("/W3") || flag == QLatin1String("/W4") || flag == QLatin1String("/Wall"))
} else if (flag == QLatin1String("/W3") || flag == QLatin1String("/W4")
|| flag == QLatin1String("/Wall")) {
inferWarningsForLevel(3, flags);
}
WarningFlagAdder add(flag, flags);
if (add.triggered())
@@ -1092,14 +1107,17 @@ ToolChain::BuiltInHeaderPathsRunner MsvcToolChain::createBuiltInHeaderPathsRunne
return [this, env](const QStringList &, const QString &) {
QMutexLocker locker(m_headerPathsMutex);
if (m_headerPaths.isEmpty()) {
foreach (const QString &path, env.value(QLatin1String("INCLUDE")).split(QLatin1Char(';')))
foreach (const QString &path,
env.value(QLatin1String("INCLUDE")).split(QLatin1Char(';'))) {
m_headerPaths.append({path, HeaderPathType::BuiltIn});
}
}
return m_headerPaths;
};
}
HeaderPaths MsvcToolChain::builtInHeaderPaths(const QStringList &cxxflags, const Utils::FileName &sysRoot) const
HeaderPaths MsvcToolChain::builtInHeaderPaths(const QStringList &cxxflags,
const Utils::FileName &sysRoot) const
{
return createBuiltInHeaderPathsRunner()(cxxflags, sysRoot.toString());
}
@@ -1138,7 +1156,9 @@ QString MsvcToolChain::makeCommand(const Utils::Environment &environment) const
QString command;
if (useJom) {
tmp = environment.searchInPath(jom, {Utils::FileName::fromString(QCoreApplication::applicationDirPath())});
tmp = environment.searchInPath(jom,
{Utils::FileName::fromString(
QCoreApplication::applicationDirPath())});
if (!tmp.isEmpty())
command = tmp.toString();
}
@@ -1163,7 +1183,8 @@ Utils::FileName MsvcToolChain::compilerCommand() const
Utils::Environment env = Utils::Environment::systemEnvironment();
addToEnvironment(env);
Utils::FileName clexe = env.searchInPath(QLatin1String("cl.exe"), {}, [](const Utils::FileName &name) {
Utils::FileName clexe
= env.searchInPath(QLatin1String("cl.exe"), {}, [](const Utils::FileName &name) {
QDir dir(QDir::cleanPath(name.toFileInfo().absolutePath() + QStringLiteral("/..")));
do {
if (QFile::exists(dir.absoluteFilePath(QStringLiteral("vcvarsall.bat")))
@@ -1186,10 +1207,10 @@ IOutputParser *MsvcToolChain::outputParser() const
// call setFromMsvcToolChain().
// --------------------------------------------------------------------------
MsvcBasedToolChainConfigWidget::MsvcBasedToolChainConfigWidget(ToolChain *tc) :
ToolChainConfigWidget(tc),
m_nameDisplayLabel(new QLabel(this)),
m_varsBatDisplayLabel(new QLabel(this))
MsvcBasedToolChainConfigWidget::MsvcBasedToolChainConfigWidget(ToolChain *tc)
: ToolChainConfigWidget(tc)
, m_nameDisplayLabel(new QLabel(this))
, m_varsBatDisplayLabel(new QLabel(this))
{
m_nameDisplayLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
m_mainLayout->addRow(m_nameDisplayLabel);
@@ -1200,7 +1221,7 @@ MsvcBasedToolChainConfigWidget::MsvcBasedToolChainConfigWidget(ToolChain *tc) :
void MsvcBasedToolChainConfigWidget::setFromMsvcToolChain()
{
const auto *tc = static_cast<const MsvcToolChain *>(toolChain());
QTC_ASSERT(tc, return);
QTC_ASSERT(tc, return );
m_nameDisplayLabel->setText(tc->displayName());
QString varsBatDisplay = QDir::toNativeSeparators(tc->varsBat());
if (!tc->varsBatArg().isEmpty()) {
@@ -1214,8 +1235,8 @@ void MsvcBasedToolChainConfigWidget::setFromMsvcToolChain()
// MsvcToolChainConfigWidget
// --------------------------------------------------------------------------
MsvcToolChainConfigWidget::MsvcToolChainConfigWidget(ToolChain *tc) :
MsvcBasedToolChainConfigWidget(tc)
MsvcToolChainConfigWidget::MsvcToolChainConfigWidget(ToolChain *tc)
: MsvcBasedToolChainConfigWidget(tc)
{
addErrorLabel();
setFromMsvcToolChain();
@@ -1244,8 +1265,10 @@ ClangClToolChainConfigWidget::ClangClToolChainConfigWidget(ToolChain *tc)
setFromClangClToolChain();
if (m_compilerCommand) {
connect(m_compilerCommand, &Utils::PathChooser::rawPathChanged,
this, &ClangClToolChainConfigWidget::dirty);
connect(m_compilerCommand,
&Utils::PathChooser::rawPathChanged,
this,
&ClangClToolChainConfigWidget::dirty);
}
}
@@ -1262,28 +1285,28 @@ void ClangClToolChainConfigWidget::setFromClangClToolChain()
static const MsvcToolChain *findMsvcToolChain(unsigned char wordWidth, Abi::OSFlavor flavor)
{
return Utils::findOrDefault(g_availableMsvcToolchains,
[wordWidth, flavor] (const MsvcToolChain *tc)
{ const Abi abi = tc->targetAbi();
return abi.osFlavor() == flavor
&& wordWidth == abi.wordWidth();} );
[wordWidth, flavor](const MsvcToolChain *tc) {
const Abi abi = tc->targetAbi();
return abi.osFlavor() == flavor && wordWidth == abi.wordWidth();
});
}
static QVersionNumber clangClVersion(const QString& clangClPath)
static QVersionNumber clangClVersion(const QString &clangClPath)
{
Utils::SynchronousProcess clangClProcess;
const Utils::SynchronousProcessResponse response = clangClProcess.runBlocking(
clangClPath, {QStringLiteral("--version")});
const Utils::SynchronousProcessResponse response
= clangClProcess.runBlocking(clangClPath, {QStringLiteral("--version")});
if (response.result != Utils::SynchronousProcessResponse::Finished || response.exitCode != 0)
return {};
const QRegularExpressionMatch match = QRegularExpression(
QStringLiteral("clang version (\\d+(\\.\\d+)+)")).match(response.stdOut());
QStringLiteral("clang version (\\d+(\\.\\d+)+)"))
.match(response.stdOut());
if (!match.hasMatch())
return {};
return QVersionNumber::fromString(match.captured(1));
}
static const MsvcToolChain *selectMsvcToolChain(const QString &clangClPath,
unsigned char wordWidth)
static const MsvcToolChain *selectMsvcToolChain(const QString &clangClPath, unsigned char wordWidth)
{
const MsvcToolChain *toolChain = nullptr;
const QVersionNumber version = clangClVersion(clangClPath);
@@ -1297,8 +1320,9 @@ static const MsvcToolChain *selectMsvcToolChain(const QString &clangClPath,
return toolChain;
}
static QList<ToolChain *> detectClangClToolChainInPath(
const QString &clangClPath, const QList<ToolChain *> &alreadyKnown, bool isDefault = false)
static QList<ToolChain *> detectClangClToolChainInPath(const QString &clangClPath,
const QList<ToolChain *> &alreadyKnown,
bool isDefault = false)
{
QList<ToolChain *> res;
const unsigned char wordWidth = Utils::is64BitWindowsBinary(clangClPath) ? 64 : 32;
@@ -1316,18 +1340,17 @@ static QList<ToolChain *> detectClangClToolChainInPath(
.arg(QLatin1String(isDefault ? "Default " : ""))
.arg(wordWidth)
.arg(Abi::toString(targetAbi.osFlavor()).toUpper());
for (auto language: {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
for (auto language : {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
ClangClToolChain *tc = static_cast<ClangClToolChain *>(
Utils::findOrDefault(
alreadyKnown,
[&targetAbi, &language, &clangClPath, &systemEnvironment](ToolChain *tc) -> bool {
Utils::findOrDefault(alreadyKnown, [&](ToolChain *tc) -> bool {
if (tc->typeId() != Constants::CLANG_CL_TOOLCHAIN_TYPEID)
return false;
if (tc->targetAbi() != targetAbi)
return false;
if (tc->language() != language)
return false;
return systemEnvironment.isSameExecutable(tc->compilerCommand().toString(), clangClPath);
return systemEnvironment.isSameExecutable(tc->compilerCommand().toString(),
clangClPath);
}));
if (!tc) {
tc = new ClangClToolChain(name, clangClPath, language, ToolChain::AutoDetection);
@@ -1382,16 +1405,17 @@ void ClangClToolChainConfigWidget::discardImpl()
// clang-cl.exe as a [to some extent] compatible drop-in replacement for cl.
// --------------------------------------------------------------------------
ClangClToolChain::ClangClToolChain(const QString &name, const QString &clangPath,
ClangClToolChain::ClangClToolChain(const QString &name,
const QString &clangPath,
Core::Id language,
Detection d)
: MsvcToolChain(Constants::CLANG_CL_TOOLCHAIN_TYPEID, name, Abi(), "", "", language, d)
, m_clangPath(clangPath)
{
}
{}
ClangClToolChain::ClangClToolChain() : MsvcToolChain(Constants::CLANG_CL_TOOLCHAIN_TYPEID)
{ }
ClangClToolChain::ClangClToolChain()
: MsvcToolChain(Constants::CLANG_CL_TOOLCHAIN_TYPEID)
{}
bool ClangClToolChain::isValid() const
{
@@ -1433,7 +1457,10 @@ ToolChain *ClangClToolChain::clone() const
return new ClangClToolChain(*this);
}
static inline QString llvmDirKey() { return QStringLiteral("ProjectExplorer.ClangClToolChain.LlvmDir"); }
static inline QString llvmDirKey()
{
return QStringLiteral("ProjectExplorer.ClangClToolChain.LlvmDir");
}
QVariantMap ClangClToolChain::toMap() const
{
@@ -1473,12 +1500,13 @@ void ClangClToolChain::resetMsvcToolChain(const MsvcToolChain *base)
initEnvModWatcher(Utils::runAsync(envModThreadPool(),
&ClangClToolChain::environmentModifications,
m_vcvarsBat, base->varsBatArg()));
m_vcvarsBat,
base->varsBatArg()));
}
bool ClangClToolChain::operator ==(const ToolChain &other) const
bool ClangClToolChain::operator==(const ToolChain &other) const
{
if (!MsvcToolChain::operator ==(other))
if (!MsvcToolChain::operator==(other))
return false;
const auto *clangClTc = static_cast<const ClangClToolChain *>(&other);
@@ -1500,8 +1528,7 @@ Macros ClangClToolChain::msvcPredefinedMacros(const QStringList &cxxflags,
arguments.append("-");
Utils::SynchronousProcessResponse response = cpp.runBlocking(compilerCommand().toString(),
arguments);
if (response.result != Utils::SynchronousProcessResponse::Finished ||
response.exitCode != 0) {
if (response.result != Utils::SynchronousProcessResponse::Finished || response.exitCode != 0) {
// Show the warning but still parse the output.
QTC_CHECK(false && "clang-cl exited with non-zero code.");
}
@@ -1532,7 +1559,8 @@ QSet<Core::Id> MsvcToolChainFactory::supportedLanguages() const
return {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID};
}
QString MsvcToolChainFactory::vcVarsBatFor(const QString &basePath, MsvcToolChain::Platform platform,
QString MsvcToolChainFactory::vcVarsBatFor(const QString &basePath,
MsvcToolChain::Platform platform,
const QVersionNumber &v)
{
QString result;
@@ -1547,17 +1575,16 @@ QString MsvcToolChainFactory::vcVarsBatFor(const QString &basePath, MsvcToolChai
return result;
}
static QList<ToolChain *> findOrCreateToolChain(
const QList<ToolChain *> &alreadyKnown,
const QString &name, const Abi &abi,
const QString &varsBat, const QString &varsBatArg,
static QList<ToolChain *> findOrCreateToolChain(const QList<ToolChain *> &alreadyKnown,
const QString &name,
const Abi &abi,
const QString &varsBat,
const QString &varsBatArg,
ToolChain::Detection d = ToolChain::ManualDetection)
{
QList<ToolChain *> res;
for (auto language: {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
ToolChain *tc = Utils::findOrDefault(
alreadyKnown,
[&varsBat, &varsBatArg, &abi, &language](ToolChain *tc) -> bool {
for (auto language : {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
ToolChain *tc = Utils::findOrDefault(alreadyKnown, [&](ToolChain *tc) -> bool {
if (tc->typeId() != Constants::MSVC_TOOLCHAIN_TYPEID)
return false;
if (tc->targetAbi() != abi)
@@ -1565,8 +1592,7 @@ static QList<ToolChain *> findOrCreateToolChain(
if (tc->language() != language)
return false;
auto mtc = static_cast<MsvcToolChain *>(tc);
return mtc->varsBat() == varsBat
&& mtc->varsBatArg() == varsBatArg;
return mtc->varsBat() == varsBat && mtc->varsBatArg() == varsBatArg;
});
if (!tc)
tc = new MsvcToolChain(name, abi, varsBat, varsBatArg, language, d);
@@ -1578,7 +1604,8 @@ static QList<ToolChain *> findOrCreateToolChain(
// Detect build tools introduced with MSVC2015
static void detectCppBuildTools2015(QList<ToolChain *> *list)
{
struct Entry {
struct Entry
{
const char *postFix;
const char *varsBatArg;
Abi::Architecture architecture;
@@ -1586,25 +1613,29 @@ static void detectCppBuildTools2015(QList<ToolChain *> *list)
unsigned char wordSize;
};
const Entry entries[] = {
{" (x86)", "x86", Abi::X86Architecture, Abi::PEFormat, 32},
const Entry entries[] = {{" (x86)", "x86", Abi::X86Architecture, Abi::PEFormat, 32},
{" (x64)", "amd64", Abi::X86Architecture, Abi::PEFormat, 64},
{" (x86_arm)", "x86_arm", Abi::ArmArchitecture, Abi::PEFormat, 32},
{" (x64_arm)", "amd64_arm", Abi::ArmArchitecture, Abi::PEFormat, 64}
};
{" (x64_arm)", "amd64_arm", Abi::ArmArchitecture, Abi::PEFormat, 64}};
const QString name = QStringLiteral("Microsoft Visual C++ Build Tools");
const QString vcVarsBat = windowsProgramFilesDir()
+ QLatin1Char('/') + name + QStringLiteral("/vcbuildtools.bat");
const QString vcVarsBat = windowsProgramFilesDir() + QLatin1Char('/') + name
+ QStringLiteral("/vcbuildtools.bat");
if (!QFileInfo(vcVarsBat).isFile())
return;
for (const Entry &e : entries) {
const Abi abi(e.architecture, Abi::WindowsOS, Abi::WindowsMsvc2015Flavor,
e.format, e.wordSize);
for (auto language: {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
list->append(new MsvcToolChain(name + QLatin1String(e.postFix), abi,
vcVarsBat, QLatin1String(e.varsBatArg),
language, ToolChain::AutoDetection));
const Abi abi(e.architecture,
Abi::WindowsOS,
Abi::WindowsMsvc2015Flavor,
e.format,
e.wordSize);
for (auto language : {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
list->append(new MsvcToolChain(name + QLatin1String(e.postFix),
abi,
vcVarsBat,
QLatin1String(e.varsBatArg),
language,
ToolChain::AutoDetection));
}
}
}
@@ -1614,13 +1645,17 @@ QList<ToolChain *> MsvcToolChainFactory::autoDetect(const QList<ToolChain *> &al
QList<ToolChain *> results;
// 1) Installed SDKs preferred over standalone Visual studio
const QSettings sdkRegistry(QLatin1String("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows"),
const QSettings
sdkRegistry(QLatin1String(
"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows"),
QSettings::NativeFormat);
const QString defaultSdkPath = sdkRegistry.value(QLatin1String("CurrentInstallFolder")).toString();
const QString defaultSdkPath = sdkRegistry.value(QLatin1String("CurrentInstallFolder"))
.toString();
if (!defaultSdkPath.isEmpty()) {
foreach (const QString &sdkKey, sdkRegistry.childGroups()) {
const QString name = sdkRegistry.value(sdkKey + QLatin1String("/ProductName")).toString();
const QString folder = sdkRegistry.value(sdkKey + QLatin1String("/InstallationFolder")).toString();
const QString folder = sdkRegistry.value(sdkKey + QLatin1String("/InstallationFolder"))
.toString();
if (folder.isEmpty())
continue;
@@ -1632,17 +1667,22 @@ QList<ToolChain *> MsvcToolChainFactory::autoDetect(const QList<ToolChain *> &al
continue;
QList<ToolChain *> tmp;
const QVector<QPair<MsvcToolChain::Platform, QString> > platforms = {
const QVector<QPair<MsvcToolChain::Platform, QString>> platforms = {
{MsvcToolChain::x86, "x86"},
{MsvcToolChain::amd64, "x64"},
{MsvcToolChain::ia64, "ia64"},
};
for (auto platform: platforms) {
tmp.append(findOrCreateToolChain(
alreadyKnown,
generateDisplayName(name, MsvcToolChain::WindowsSDK, platform.first),
findAbiOfMsvc(MsvcToolChain::WindowsSDK, platform.first, sdkKey),
fi.absoluteFilePath(), "/" + platform.second, ToolChain::AutoDetection));
for (auto platform : platforms) {
tmp.append(findOrCreateToolChain(alreadyKnown,
generateDisplayName(name,
MsvcToolChain::WindowsSDK,
platform.first),
findAbiOfMsvc(MsvcToolChain::WindowsSDK,
platform.first,
sdkKey),
fi.absoluteFilePath(),
"/" + platform.second,
ToolChain::AutoDetection));
}
// Make sure the default is front.
if (folder == defaultSdkPath)
@@ -1657,23 +1697,27 @@ QList<ToolChain *> MsvcToolChainFactory::autoDetect(const QList<ToolChain *> &al
// x86_arm was put before amd64_arm as a workaround for auto detected windows phone
// toolchains. As soon as windows phone builds support x64 cross builds, this change
// can be reverted.
const MsvcToolChain::Platform platforms[] = {
MsvcToolChain::x86, MsvcToolChain::amd64_x86,
MsvcToolChain::amd64, MsvcToolChain::x86_amd64,
MsvcToolChain::arm, MsvcToolChain::x86_arm, MsvcToolChain::amd64_arm,
MsvcToolChain::ia64, MsvcToolChain::x86_ia64
};
const MsvcToolChain::Platform platforms[] = {MsvcToolChain::x86,
MsvcToolChain::amd64_x86,
MsvcToolChain::amd64,
MsvcToolChain::x86_amd64,
MsvcToolChain::arm,
MsvcToolChain::x86_arm,
MsvcToolChain::amd64_arm,
MsvcToolChain::ia64,
MsvcToolChain::x86_ia64};
foreach (const VisualStudioInstallation &i, detectVisualStudio()) {
for (MsvcToolChain::Platform platform : platforms) {
const bool toolchainInstalled =
QFileInfo(vcVarsBatFor(i.vcVarsPath, platform, i.version)).isFile();
const bool toolchainInstalled
= QFileInfo(vcVarsBatFor(i.vcVarsPath, platform, i.version)).isFile();
if (hostSupportsPlatform(platform) && toolchainInstalled) {
results.append(findOrCreateToolChain(
alreadyKnown,
results.append(
findOrCreateToolChain(alreadyKnown,
generateDisplayName(i.vsName, MsvcToolChain::VS, platform),
findAbiOfMsvc(MsvcToolChain::VS, platform, i.vsName),
i.vcVarsAll, platformName(platform),
i.vcVarsAll,
platformName(platform),
ToolChain::AutoDetection));
}
}
@@ -1712,8 +1756,10 @@ QList<ToolChain *> ClangClToolChainFactory::autoDetect(const QList<ToolChain *>
QString qtCreatorsClang = Core::ICore::clangExecutable(CLANG_BINDIR);
if (!qtCreatorsClang.isEmpty()) {
qtCreatorsClang = Utils::FileName::fromString(qtCreatorsClang).parentDir()
.appendPath("clang-cl.exe").toString();
qtCreatorsClang = Utils::FileName::fromString(qtCreatorsClang)
.parentDir()
.appendPath("clang-cl.exe")
.toString();
results.append(detectClangClToolChainInPath(qtCreatorsClang, alreadyKnown, true));
known.append(results);
}
@@ -1741,14 +1787,13 @@ ToolChain *ClangClToolChainFactory::create(Core::Id l)
return new ClangClToolChain("clang-cl", "", l, ToolChain::ManualDetection);
}
bool MsvcToolChain::operator ==(const ToolChain &other) const
bool MsvcToolChain::operator==(const ToolChain &other) const
{
if (!ToolChain::operator ==(other))
if (!ToolChain::operator==(other))
return false;
const auto *msvcTc = dynamic_cast<const MsvcToolChain *>(&other);
return targetAbi() == msvcTc->targetAbi()
&& m_vcvarsBat == msvcTc->m_vcvarsBat
return targetAbi() == msvcTc->targetAbi() && m_vcvarsBat == msvcTc->m_vcvarsBat
&& m_varsBatArg == msvcTc->m_varsBatArg;
}
@@ -1795,12 +1840,12 @@ Utils::optional<QString> MsvcToolChain::generateEnvironmentSettings(const Utils:
runEnv.unset(QLatin1String("ORIGINALPATH"));
run.setEnvironment(runEnv.toStringList());
run.setTimeoutS(30);
Utils::FileName cmdPath = Utils::FileName::fromUserInput(QString::fromLocal8Bit(qgetenv("COMSPEC")));
Utils::FileName cmdPath = Utils::FileName::fromUserInput(
QString::fromLocal8Bit(qgetenv("COMSPEC")));
if (cmdPath.isEmpty())
cmdPath = env.searchInPath(QLatin1String("cmd.exe"));
// Windows SDK setup scripts require command line switches for environment expansion.
QStringList cmdArguments({
QLatin1String("/E:ON"), QLatin1String("/V:ON"), QLatin1String("/c")});
QStringList cmdArguments({QLatin1String("/E:ON"), QLatin1String("/V:ON"), QLatin1String("/c")});
cmdArguments << QDir::toNativeSeparators(saver.fileName());
if (debug)
qDebug() << "readEnvironmentSetting: " << call << cmdPath << cmdArguments.join(' ')
@@ -1818,7 +1863,8 @@ Utils::optional<QString> MsvcToolChain::generateEnvironmentSettings(const Utils:
command += ' ' + batchArgs;
return QCoreApplication::translate("ProjectExplorer::Internal::MsvcToolChain",
"Failed to retrieve MSVC Environment from \"%1\":\n"
"%2").arg(command, message);
"%2")
.arg(command, message);
}
// The SDK/MSVC scripts do not return exit codes != 0. Check on stdout.
@@ -1858,7 +1904,7 @@ bool MsvcToolChainFactory::canRestore(const QVariantMap &data)
return id == Constants::MSVC_TOOLCHAIN_TYPEID;
}
template <class ToolChainType>
template<class ToolChainType>
ToolChainType *readFromMap(const QVariantMap &data)
{
auto result = new ToolChainType;
@@ -1904,12 +1950,11 @@ MsvcToolChain::WarningFlagAdder::WarningFlagAdder(const QString &flag, WarningFl
m_triggered = true;
}
void MsvcToolChain::WarningFlagAdder::operator ()(int warningCode, WarningFlags flagsSet)
void MsvcToolChain::WarningFlagAdder::operator()(int warningCode, WarningFlags flagsSet)
{
if (m_triggered)
return;
if (warningCode == m_warningCode)
{
if (warningCode == m_warningCode) {
m_triggered = true;
if (m_doesEnable)
m_flags |= flagsSet;

60
src/plugins/projectexplorer/msvctoolchain.h
View File

@@ -38,7 +38,9 @@
QT_FORWARD_DECLARE_CLASS(QLabel)
QT_FORWARD_DECLARE_CLASS(QVersionNumber)
namespace Utils { class PathChooser; }
namespace Utils {
class PathChooser;
}
namespace ProjectExplorer {
namespace Internal {
@@ -51,20 +53,14 @@ class MsvcToolChain : public ToolChain
{
public:
enum Type { WindowsSDK, VS };
enum Platform { x86,
amd64,
x86_amd64,
ia64,
x86_ia64,
arm,
x86_arm,
amd64_arm,
amd64_x86
};
enum Platform { x86, amd64, x86_amd64, ia64, x86_ia64, arm, x86_arm, amd64_arm, amd64_x86 };
explicit MsvcToolChain(const QString &name, const Abi &abi,
const QString &varsBat, const QString &varsBatArg,
Core::Id l, Detection d = ManualDetection);
explicit MsvcToolChain(const QString &name,
const Abi &abi,
const QString &varsBat,
const QString &varsBatArg,
Core::Id l,
Detection d = ManualDetection);
MsvcToolChain(const MsvcToolChain &other);
MsvcToolChain();
~MsvcToolChain() override;
@@ -104,7 +100,7 @@ public:
QString varsBat() const { return m_vcvarsBat; }
void setVarsBatArg(const QString &varsBA) { m_varsBatArg = varsBA; }
bool operator == (const ToolChain &) const override;
bool operator==(const ToolChain &) const override;
static void cancelMsvcToolChainDetection();
static Utils::optional<QString> generateEnvironmentSettings(const Utils::Environment &env,
@@ -112,7 +108,6 @@ public:
const QString &batchArgs,
QMap<QString, QString> &envPairs);
protected:
class WarningFlagAdder
{
@@ -120,22 +115,27 @@ protected:
WarningFlags &m_flags;
bool m_doesEnable = false;
bool m_triggered = false;
public:
WarningFlagAdder(const QString &flag, WarningFlags &flags);
void operator ()(int warningCode, WarningFlags flagsSet);
void operator()(int warningCode, WarningFlags flagsSet);
bool triggered() const;
};
explicit MsvcToolChain(Core::Id typeId, const QString &name, const Abi &abi,
const QString &varsBat, const QString &varsBatArg,
Core::Id l, Detection d);
explicit MsvcToolChain(Core::Id typeId,
const QString &name,
const Abi &abi,
const QString &varsBat,
const QString &varsBatArg,
Core::Id l,
Detection d);
explicit MsvcToolChain(Core::Id typeId);
static void inferWarningsForLevel(int warningLevel, WarningFlags &flags);
void toolChainUpdated() override;
Utils::Environment readEnvironmentSetting(const Utils::Environment& env) const;
Utils::Environment readEnvironmentSetting(const Utils::Environment &env) const;
// Function must be thread-safe!
virtual Macros msvcPredefinedMacros(const QStringList &cxxflags,
const Utils::Environment &env) const;
@@ -149,7 +149,8 @@ protected:
QList<Utils::EnvironmentItem> environmentItems;
};
static void environmentModifications(QFutureInterface<GenerateEnvResult> &future,
QString vcvarsBat, QString varsBatArg);
QString vcvarsBat,
QString varsBatArg);
void initEnvModWatcher(const QFuture<GenerateEnvResult> &future);
private:
@@ -177,9 +178,7 @@ protected:
class ClangClToolChain : public MsvcToolChain
{
public:
ClangClToolChain(const QString &name, const QString &llvmDir,
Core::Id language,
Detection d);
ClangClToolChain(const QString &name, const QString &llvmDir, Core::Id language, Detection d);
ClangClToolChain();
bool isValid() const override;
@@ -204,7 +203,8 @@ public:
const Core::Id &language,
const Macros &macros) const override;
bool operator ==(const ToolChain &) const override;
bool operator==(const ToolChain &) const override;
private:
QString m_clangPath;
};
@@ -226,7 +226,8 @@ public:
bool canRestore(const QVariantMap &data) override;
ToolChain *restore(const QVariantMap &data) override;
static QString vcVarsBatFor(const QString &basePath, MsvcToolChain::Platform platform,
static QString vcVarsBatFor(const QString &basePath,
MsvcToolChain::Platform platform,
const QVersionNumber &v);
};
@@ -246,7 +247,6 @@ public:
ToolChain *create(Core::Id l) override;
};
// --------------------------------------------------------------------------
// MsvcBasedToolChainConfigWidget
// --------------------------------------------------------------------------
@@ -259,10 +259,10 @@ public:
explicit MsvcBasedToolChainConfigWidget(ToolChain *);
protected:
void applyImpl() override { }
void applyImpl() override {}
void discardImpl() override { setFromMsvcToolChain(); }
bool isDirtyImpl() const override { return false; }
void makeReadOnlyImpl() override { }
void makeReadOnlyImpl() override {}
void setFromMsvcToolChain();