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

McuSupport: Rename remaining ToolChain things to Toolchain

Browse Source 
Change-Id: Icd90402501b3ca2197e124731e26d2f9b0704e0a
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
This commit is contained in:
hjk
2024-01-22 17:37:12 +01:00
parent 8ef85e481a
commit d7c1fe129f
15 changed files with 207 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/plugins/mcusupport/mcuabstracttargetfactory.h
View File

@@ -28,7 +28,7 @@ public:
const McuPackagePtr &qtForMCUsPackage) const McuPackagePtr &qtForMCUsPackage)
= 0; = 0;
using AdditionalPackages using AdditionalPackages
= QPair<QHash<QString, McuToolChainPackagePtr>, QHash<QString, McuPackagePtr>>; = QPair<QHash<QString, McuToolchainPackagePtr>, QHash<QString, McuPackagePtr>>;
virtual AdditionalPackages getAdditionalPackages() const { return {}; } virtual AdditionalPackages getAdditionalPackages() const { return {}; }
}; // struct McuAbstractTargetFactory }; // struct McuAbstractTargetFactory
} // namespace McuSupport::Internal } // namespace McuSupport::Internal

60
src/plugins/mcusupport/mcukitmanager.cpp
View File

@@ -75,22 +75,22 @@ static const int KIT_VERSION = 9; // Bumps up whenever details in Kit creation c
class McuKitFactory class McuKitFactory
{ {
public: public:
static void setKitToolchains(Kit *k, const McuToolChainPackagePtr &tcPackage) static void setKitToolchains(Kit *k, const McuToolchainPackagePtr &tcPackage)
{ {
switch (tcPackage->toolchainType()) { switch (tcPackage->toolchainType()) {
case McuToolChainPackage::ToolChainType::Unsupported: case McuToolchainPackage::ToolchainType::Unsupported:
return; return;
case McuToolChainPackage::ToolChainType::GHS: case McuToolchainPackage::ToolchainType::GHS:
case McuToolChainPackage::ToolChainType::GHSArm: case McuToolchainPackage::ToolchainType::GHSArm:
return; // No Green Hills toolchain, because support for it is missing. return; // No Green Hills toolchain, because support for it is missing.
case McuToolChainPackage::ToolChainType::IAR: case McuToolchainPackage::ToolchainType::IAR:
case McuToolChainPackage::ToolChainType::KEIL: case McuToolchainPackage::ToolchainType::KEIL:
case McuToolChainPackage::ToolChainType::MSVC: case McuToolchainPackage::ToolchainType::MSVC:
case McuToolChainPackage::ToolChainType::GCC: case McuToolchainPackage::ToolchainType::GCC:
case McuToolChainPackage::ToolChainType::MinGW: case McuToolchainPackage::ToolchainType::MinGW:
case McuToolChainPackage::ToolChainType::ArmGcc: case McuToolchainPackage::ToolchainType::ArmGcc:
ToolchainKitAspect::setToolchain(k, ToolchainKitAspect::setToolchain(k,
tcPackage->toolChain( tcPackage->toolChain(
ProjectExplorer::Constants::C_LANGUAGE_ID)); ProjectExplorer::Constants::C_LANGUAGE_ID));
@@ -116,7 +116,7 @@ public:
k->setValue(KIT_MCUTARGET_SDKVERSION_KEY, mcuTarget->qulVersion().toString()); k->setValue(KIT_MCUTARGET_SDKVERSION_KEY, mcuTarget->qulVersion().toString());
k->setValue(KIT_MCUTARGET_KITVERSION_KEY, KIT_VERSION); k->setValue(KIT_MCUTARGET_KITVERSION_KEY, KIT_VERSION);
k->setValue(KIT_MCUTARGET_OS_KEY, static_cast<int>(mcuTarget->os())); k->setValue(KIT_MCUTARGET_OS_KEY, static_cast<int>(mcuTarget->os()));
k->setValue(KIT_MCUTARGET_TOOLCHAIN_KEY, mcuTarget->toolChainPackage()->toolChainName()); k->setValue(KIT_MCUTARGET_TOOLCHAIN_KEY, mcuTarget->toolChainPackage()->toolchainName());
k->setAutoDetected(false); k->setAutoDetected(false);
k->makeSticky(); k->makeSticky();
if (mcuTarget->toolChainPackage()->isDesktopToolchain()) if (mcuTarget->toolChainPackage()->isDesktopToolchain())
@@ -136,25 +136,25 @@ public:
k->setIrrelevantAspects(irrelevant); k->setIrrelevantAspects(irrelevant);
} }
static void setKitDebugger(Kit *k, const McuToolChainPackagePtr &tcPackage) static void setKitDebugger(Kit *k, const McuToolchainPackagePtr &tcPackage)
{ {
if (tcPackage->isDesktopToolchain()) { if (tcPackage->isDesktopToolchain()) {
// Qt Creator seems to be smart enough to deduce the right Kit debugger from the ToolChain // Qt Creator seems to be smart enough to deduce the right Kit debugger from the Toolchain
return; return;
} }
switch (tcPackage->toolchainType()) { switch (tcPackage->toolchainType()) {
case McuToolChainPackage::ToolChainType::Unsupported: case McuToolchainPackage::ToolchainType::Unsupported:
case McuToolChainPackage::ToolChainType::GHS: case McuToolchainPackage::ToolchainType::GHS:
case McuToolChainPackage::ToolChainType::GHSArm: case McuToolchainPackage::ToolchainType::GHSArm:
case McuToolChainPackage::ToolChainType::IAR: case McuToolchainPackage::ToolchainType::IAR:
return; // No Green Hills and IAR debugger, because support for it is missing. return; // No Green Hills and IAR debugger, because support for it is missing.
case McuToolChainPackage::ToolChainType::KEIL: case McuToolchainPackage::ToolchainType::KEIL:
case McuToolChainPackage::ToolChainType::MSVC: case McuToolchainPackage::ToolchainType::MSVC:
case McuToolChainPackage::ToolChainType::GCC: case McuToolchainPackage::ToolchainType::GCC:
case McuToolChainPackage::ToolChainType::MinGW: case McuToolchainPackage::ToolchainType::MinGW:
case McuToolChainPackage::ToolChainType::ArmGcc: { case McuToolchainPackage::ToolchainType::ArmGcc: {
const QVariant debuggerId = tcPackage->debuggerId(); const QVariant debuggerId = tcPackage->debuggerId();
if (debuggerId.isValid()) { if (debuggerId.isValid()) {
Debugger::DebuggerKitAspect::setDebugger(k, debuggerId); Debugger::DebuggerKitAspect::setDebugger(k, debuggerId);
@@ -252,10 +252,10 @@ public:
using namespace CMakeProjectManager; using namespace CMakeProjectManager;
auto configMap = cMakeConfigToMap(CMakeConfigurationKitAspect::configuration(k)); auto configMap = cMakeConfigToMap(CMakeConfigurationKitAspect::configuration(k));
// CMake ToolChain file for ghs handles CMAKE_*_COMPILER autonomously // CMake Toolchain file for ghs handles CMAKE_*_COMPILER autonomously
const QList autonomousCompilerDetectionToolchains{ const QList autonomousCompilerDetectionToolchains{
McuToolChainPackage::ToolChainType::GHS, McuToolchainPackage::ToolchainType::GHS,
McuToolChainPackage::ToolChainType::GHSArm, McuToolchainPackage::ToolchainType::GHSArm,
}; };
if (!autonomousCompilerDetectionToolchains.contains( if (!autonomousCompilerDetectionToolchains.contains(
mcuTarget->toolChainPackage()->toolchainType())) { mcuTarget->toolChainPackage()->toolchainType())) {
@@ -324,8 +324,8 @@ public:
if (HostOsInfo::isWindowsHost()) { if (HostOsInfo::isWindowsHost()) {
auto type = mcuTarget->toolChainPackage()->toolchainType(); auto type = mcuTarget->toolChainPackage()->toolchainType();
if (type == McuToolChainPackage::ToolChainType::GHS if (type == McuToolchainPackage::ToolchainType::GHS
|| type == McuToolChainPackage::ToolChainType::GHSArm) { || type == McuToolchainPackage::ToolchainType::GHSArm) {
// See https://bugreports.qt.io/browse/UL-4247?focusedCommentId=565802&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-565802 // See https://bugreports.qt.io/browse/UL-4247?focusedCommentId=565802&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-565802
// and https://bugreports.qt.io/browse/UL-4247?focusedCommentId=565803&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-565803 // and https://bugreports.qt.io/browse/UL-4247?focusedCommentId=565803&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-565803
CMakeGeneratorKitAspect::setGenerator(k, "NMake Makefiles JOM"); CMakeGeneratorKitAspect::setGenerator(k, "NMake Makefiles JOM");
@@ -387,9 +387,9 @@ Kit *newKit(const McuTarget *mcuTarget, const McuPackagePtr &qtForMCUsSdk)
// Kit Information // Kit Information
QString generateKitNameFromTarget(const McuTarget *mcuTarget) QString generateKitNameFromTarget(const McuTarget *mcuTarget)
{ {
McuToolChainPackagePtr tcPkg = mcuTarget->toolChainPackage(); McuToolchainPackagePtr tcPkg = mcuTarget->toolChainPackage();
const QString compilerName = tcPkg ? QString::fromLatin1(" (%1)").arg( const QString compilerName = tcPkg ? QString::fromLatin1(" (%1)").arg(
tcPkg->toolChainName().toUpper()) tcPkg->toolchainName().toUpper())
: ""; : "";
const QString colorDepth = mcuTarget->colorDepth() != McuTarget::UnspecifiedColorDepth const QString colorDepth = mcuTarget->colorDepth() != McuTarget::UnspecifiedColorDepth
? QString::fromLatin1(" %1bpp").arg(mcuTarget->colorDepth()) ? QString::fromLatin1(" %1bpp").arg(mcuTarget->colorDepth())
@@ -453,7 +453,7 @@ QList<Kit *> existingKits(const McuTarget *mcuTarget)
&& kit->value(KIT_MCUTARGET_OS_KEY).toInt() && kit->value(KIT_MCUTARGET_OS_KEY).toInt()
== static_cast<int>(mcuTarget->os()) == static_cast<int>(mcuTarget->os())
&& kit->value(KIT_MCUTARGET_TOOLCHAIN_KEY) && kit->value(KIT_MCUTARGET_TOOLCHAIN_KEY)
== mcuTarget->toolChainPackage()->toolChainName())); == mcuTarget->toolChainPackage()->toolchainName()));
}); });
} }

80
src/plugins/mcusupport/mcupackage.cpp
View File

@@ -352,12 +352,12 @@ const QMap<QString, QString> McuPackage::packageLabelTranslations {
{"Path to project for Renesas e2 Studio", Tr::tr("Path to project for Renesas e2 Studio")} {"Path to project for Renesas e2 Studio", Tr::tr("Path to project for Renesas e2 Studio")}
}; };
McuToolChainPackage::McuToolChainPackage(const SettingsHandler::Ptr &settingsHandler, McuToolchainPackage::McuToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
const QString &label, const QString &label,
const FilePath &defaultPath, const FilePath &defaultPath,
const QList<FilePath> &detectionPaths, const QList<FilePath> &detectionPaths,
const Key &settingsKey, const Key &settingsKey,
McuToolChainPackage::ToolChainType type, McuToolchainPackage::ToolchainType type,
const QStringList &versions, const QStringList &versions,
const QString &cmakeVarName, const QString &cmakeVarName,
const QString &envVarName, const QString &envVarName,
@@ -375,18 +375,18 @@ McuToolChainPackage::McuToolChainPackage(const SettingsHandler::Ptr &settingsHan
, m_type(type) , m_type(type)
{} {}
McuToolChainPackage::ToolChainType McuToolChainPackage::toolchainType() const McuToolchainPackage::ToolchainType McuToolchainPackage::toolchainType() const
{ {
return m_type; return m_type;
} }
bool McuToolChainPackage::isDesktopToolchain() const bool McuToolchainPackage::isDesktopToolchain() const
{ {
return m_type == ToolChainType::MSVC || m_type == ToolChainType::GCC return m_type == ToolchainType::MSVC || m_type == ToolchainType::GCC
|| m_type == ToolChainType::MinGW; || m_type == ToolchainType::MinGW;
} }
Toolchain *McuToolChainPackage::msvcToolChain(Id language) Toolchain *McuToolchainPackage::msvcToolchain(Id language)
{ {
Toolchain *toolChain = ToolchainManager::toolchain([language](const Toolchain *t) { Toolchain *toolChain = ToolchainManager::toolchain([language](const Toolchain *t) {
const Abi abi = t->targetAbi(); const Abi abi = t->targetAbi();
@@ -398,7 +398,7 @@ Toolchain *McuToolChainPackage::msvcToolChain(Id language)
return toolChain; return toolChain;
} }
Toolchain *McuToolChainPackage::gccToolChain(Id language) Toolchain *McuToolchainPackage::gccToolchain(Id language)
{ {
Toolchain *toolChain = ToolchainManager::toolchain([language](const Toolchain *t) { Toolchain *toolChain = ToolchainManager::toolchain([language](const Toolchain *t) {
const Abi abi = t->targetAbi(); const Abi abi = t->targetAbi();
@@ -408,7 +408,7 @@ Toolchain *McuToolChainPackage::gccToolChain(Id language)
return toolChain; return toolChain;
} }
static Toolchain *mingwToolChain(const FilePath &path, Id language) static Toolchain *mingwToolchain(const FilePath &path, Id language)
{ {
Toolchain *toolChain = ToolchainManager::toolchain([&path, language](const Toolchain *t) { Toolchain *toolChain = ToolchainManager::toolchain([&path, language](const Toolchain *t) {
// find a MinGW toolchain having the same path from registered toolchains // find a MinGW toolchain having the same path from registered toolchains
@@ -430,7 +430,7 @@ static Toolchain *mingwToolChain(const FilePath &path, Id language)
return toolChain; return toolChain;
} }
static Toolchain *armGccToolChain(const FilePath &path, Id language) static Toolchain *armGccToolchain(const FilePath &path, Id language)
{ {
Toolchain *toolChain = ToolchainManager::toolchain([&path, language](const Toolchain *t) { Toolchain *toolChain = ToolchainManager::toolchain([&path, language](const Toolchain *t) {
return t->compilerCommand() == path && t->language() == language; return t->compilerCommand() == path && t->language() == language;
@@ -456,7 +456,7 @@ static Toolchain *armGccToolChain(const FilePath &path, Id language)
return toolChain; return toolChain;
} }
static Toolchain *iarToolChain(const FilePath &path, Id language) static Toolchain *iarToolchain(const FilePath &path, Id language)
{ {
Toolchain *toolChain = ToolchainManager::toolchain([language](const Toolchain *t) { Toolchain *toolChain = ToolchainManager::toolchain([language](const Toolchain *t) {
return t->typeId() == BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID return t->typeId() == BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID
@@ -488,67 +488,67 @@ static Toolchain *iarToolChain(const FilePath &path, Id language)
return toolChain; return toolChain;
} }
Toolchain *McuToolChainPackage::toolChain(Id language) const Toolchain *McuToolchainPackage::toolChain(Id language) const
{ {
switch (m_type) { switch (m_type) {
case ToolChainType::MSVC: case ToolchainType::MSVC:
return msvcToolChain(language); return msvcToolchain(language);
case ToolChainType::GCC: case ToolchainType::GCC:
return gccToolChain(language); return gccToolchain(language);
case ToolChainType::MinGW: { case ToolchainType::MinGW: {
const QLatin1String compilerName( const QLatin1String compilerName(
language == ProjectExplorer::Constants::C_LANGUAGE_ID ? "gcc" : "g++"); language == ProjectExplorer::Constants::C_LANGUAGE_ID ? "gcc" : "g++");
const FilePath compilerPath = (path() / "bin" / compilerName).withExecutableSuffix(); const FilePath compilerPath = (path() / "bin" / compilerName).withExecutableSuffix();
return mingwToolChain(compilerPath, language); return mingwToolchain(compilerPath, language);
} }
case ToolChainType::IAR: { case ToolchainType::IAR: {
const FilePath compiler = (path() / "/bin/iccarm").withExecutableSuffix(); const FilePath compiler = (path() / "/bin/iccarm").withExecutableSuffix();
return iarToolChain(compiler, language); return iarToolchain(compiler, language);
} }
case ToolChainType::ArmGcc: case ToolchainType::ArmGcc:
case ToolChainType::KEIL: case ToolchainType::KEIL:
case ToolChainType::GHS: case ToolchainType::GHS:
case ToolChainType::GHSArm: case ToolchainType::GHSArm:
case ToolChainType::Unsupported: { case ToolchainType::Unsupported: {
const QLatin1String compilerName( const QLatin1String compilerName(
language == ProjectExplorer::Constants::C_LANGUAGE_ID ? "gcc" : "g++"); language == ProjectExplorer::Constants::C_LANGUAGE_ID ? "gcc" : "g++");
const QString comp = QLatin1String(m_type == ToolChainType::ArmGcc ? "/bin/arm-none-eabi-%1" const QString comp = QLatin1String(m_type == ToolchainType::ArmGcc ? "/bin/arm-none-eabi-%1"
: "/bar/foo-keil-%1") : "/bar/foo-keil-%1")
.arg(compilerName); .arg(compilerName);
const FilePath compiler = (path() / comp).withExecutableSuffix(); const FilePath compiler = (path() / comp).withExecutableSuffix();
return armGccToolChain(compiler, language); return armGccToolchain(compiler, language);
} }
default: default:
Q_UNREACHABLE(); Q_UNREACHABLE();
} }
} }
QString McuToolChainPackage::toolChainName() const QString McuToolchainPackage::toolchainName() const
{ {
switch (m_type) { switch (m_type) {
case ToolChainType::MSVC: case ToolchainType::MSVC:
return QLatin1String("msvc"); return QLatin1String("msvc");
case ToolChainType::GCC: case ToolchainType::GCC:
return QLatin1String("gcc"); return QLatin1String("gcc");
case ToolChainType::MinGW: case ToolchainType::MinGW:
return QLatin1String("mingw"); return QLatin1String("mingw");
case ToolChainType::ArmGcc: case ToolchainType::ArmGcc:
return QLatin1String("armgcc"); return QLatin1String("armgcc");
case ToolChainType::IAR: case ToolchainType::IAR:
return QLatin1String("iar"); return QLatin1String("iar");
case ToolChainType::KEIL: case ToolchainType::KEIL:
return QLatin1String("keil"); return QLatin1String("keil");
case ToolChainType::GHS: case ToolchainType::GHS:
return QLatin1String("ghs"); return QLatin1String("ghs");
case ToolChainType::GHSArm: case ToolchainType::GHSArm:
return QLatin1String("ghs-arm"); return QLatin1String("ghs-arm");
default: default:
return QLatin1String("unsupported"); return QLatin1String("unsupported");
} }
} }
QVariant McuToolChainPackage::debuggerId() const QVariant McuToolchainPackage::debuggerId() const
{ {
using namespace Debugger; using namespace Debugger;
@@ -556,19 +556,19 @@ QVariant McuToolChainPackage::debuggerId() const
DebuggerEngineType engineType; DebuggerEngineType engineType;
switch (m_type) { switch (m_type) {
case ToolChainType::ArmGcc: { case ToolchainType::ArmGcc: {
sub = QString::fromLatin1("bin/arm-none-eabi-gdb-py"); sub = QString::fromLatin1("bin/arm-none-eabi-gdb-py");
displayName = Tr::tr("Arm GDB at %1"); displayName = Tr::tr("Arm GDB at %1");
engineType = Debugger::GdbEngineType; engineType = Debugger::GdbEngineType;
break; break;
} }
case ToolChainType::IAR: { case ToolchainType::IAR: {
sub = QString::fromLatin1("../common/bin/CSpyBat"); sub = QString::fromLatin1("../common/bin/CSpyBat");
displayName = QLatin1String("CSpy"); displayName = QLatin1String("CSpy");
engineType = Debugger::NoEngineType; // support for IAR missing engineType = Debugger::NoEngineType; // support for IAR missing
break; break;
} }
case ToolChainType::KEIL: { case ToolchainType::KEIL: {
sub = QString::fromLatin1("UV4/UV4"); sub = QString::fromLatin1("UV4/UV4");
displayName = QLatin1String("KEIL uVision Debugger"); displayName = QLatin1String("KEIL uVision Debugger");
engineType = Debugger::UvscEngineType; engineType = Debugger::UvscEngineType;

20
src/plugins/mcusupport/mcupackage.h
View File

@@ -100,36 +100,36 @@ private:
Status m_status = Status::InvalidPath; Status m_status = Status::InvalidPath;
}; // class McuPackage }; // class McuPackage
class McuToolChainPackage final : public McuPackage class McuToolchainPackage final : public McuPackage
{ {
Q_OBJECT Q_OBJECT
public: public:
enum class ToolChainType { IAR, KEIL, MSVC, GCC, ArmGcc, GHS, GHSArm, MinGW, Unsupported }; enum class ToolchainType { IAR, KEIL, MSVC, GCC, ArmGcc, GHS, GHSArm, MinGW, Unsupported };
McuToolChainPackage(const SettingsHandler::Ptr &settingsHandler, McuToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
const QString &label, const QString &label,
const Utils::FilePath &defaultPath, const Utils::FilePath &defaultPath,
const Utils::FilePaths &detectionPaths, const Utils::FilePaths &detectionPaths,
const Utils::Key &settingsKey, const Utils::Key &settingsKey,
ToolChainType toolchainType, ToolchainType toolchainType,
const QStringList &versions, const QStringList &versions,
const QString &cmakeVarName, const QString &cmakeVarName,
const QString &envVarName, const QString &envVarName,
const McuPackageVersionDetector *versionDetector); const McuPackageVersionDetector *versionDetector);
ToolChainType toolchainType() const; ToolchainType toolchainType() const;
bool isDesktopToolchain() const; bool isDesktopToolchain() const;
ProjectExplorer::Toolchain *toolChain(Utils::Id language) const; ProjectExplorer::Toolchain *toolChain(Utils::Id language) const;
QString toolChainName() const; QString toolchainName() const;
QVariant debuggerId() const; QVariant debuggerId() const;
static ProjectExplorer::Toolchain *msvcToolChain(Utils::Id language); static ProjectExplorer::Toolchain *msvcToolchain(Utils::Id language);
static ProjectExplorer::Toolchain *gccToolChain(Utils::Id language); static ProjectExplorer::Toolchain *gccToolchain(Utils::Id language);
private: private:
const ToolChainType m_type; const ToolchainType m_type;
}; };
} // namespace McuSupport::Internal } // namespace McuSupport::Internal
Q_DECLARE_METATYPE(McuSupport::Internal::McuToolChainPackage::ToolChainType) Q_DECLARE_METATYPE(McuSupport::Internal::McuToolchainPackage::ToolchainType)

4
src/plugins/mcusupport/mcusupport_global.h
View File

@@ -19,10 +19,10 @@ namespace McuSupport::Internal {
class McuTarget; class McuTarget;
class McuAbstractPackage; class McuAbstractPackage;
class McuToolChainPackage; class McuToolchainPackage;
using McuPackagePtr = QSharedPointer<McuAbstractPackage>; using McuPackagePtr = QSharedPointer<McuAbstractPackage>;
using McuToolChainPackagePtr = QSharedPointer<McuToolChainPackage>; using McuToolchainPackagePtr = QSharedPointer<McuToolchainPackage>;
using McuTargetPtr = QSharedPointer<McuTarget>; using McuTargetPtr = QSharedPointer<McuTarget>;
static const QVersionNumber minimalVersion{2, 0, 0}; static const QVersionNumber minimalVersion{2, 0, 0};

66
src/plugins/mcusupport/mcusupportsdk.cpp
View File

@@ -152,7 +152,7 @@ McuPackagePtr createFreeRTOSSourcesPackage(const SettingsHandler::Ptr &settingsH
"https://freertos.org")}; // download url "https://freertos.org")}; // download url
} }
McuPackagePtr createUnsupportedToolChainFilePackage(const SettingsHandler::Ptr &settingsHandler, McuPackagePtr createUnsupportedToolchainFilePackage(const SettingsHandler::Ptr &settingsHandler,
const FilePath &qtForMCUSdkPath) const FilePath &qtForMCUSdkPath)
{ {
const FilePath toolchainFilePath = qtForMCUSdkPath / Constants::QUL_TOOLCHAIN_CMAKE_DIR const FilePath toolchainFilePath = qtForMCUSdkPath / Constants::QUL_TOOLCHAIN_CMAKE_DIR
@@ -166,25 +166,25 @@ McuPackagePtr createUnsupportedToolChainFilePackage(const SettingsHandler::Ptr &
{})}; {})};
} }
McuToolChainPackagePtr createUnsupportedToolChainPackage(const SettingsHandler::Ptr &settingsHandler) McuToolchainPackagePtr createUnsupportedToolchainPackage(const SettingsHandler::Ptr &settingsHandler)
{ {
return McuToolChainPackagePtr{ return McuToolchainPackagePtr{
new McuToolChainPackage(settingsHandler, new McuToolchainPackage(settingsHandler,
{}, {},
{}, {},
{}, {},
{}, {},
McuToolChainPackage::ToolChainType::Unsupported, McuToolchainPackage::ToolchainType::Unsupported,
{}, {},
{}, {},
{}, {},
nullptr)}; nullptr)};
} }
McuToolChainPackagePtr createMsvcToolChainPackage(const SettingsHandler::Ptr &settingsHandler, McuToolchainPackagePtr createMsvcToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
const QStringList &versions) const QStringList &versions)
{ {
Toolchain *toolChain = McuToolChainPackage::msvcToolChain( Toolchain *toolChain = McuToolchainPackage::msvcToolchain(
ProjectExplorer::Constants::CXX_LANGUAGE_ID); ProjectExplorer::Constants::CXX_LANGUAGE_ID);
const FilePath detectionPath = FilePath("cl").withExecutableSuffix(); const FilePath detectionPath = FilePath("cl").withExecutableSuffix();
@@ -194,22 +194,22 @@ McuToolChainPackagePtr createMsvcToolChainPackage(const SettingsHandler::Ptr &se
{"/?"}, {"/?"},
R"(\b(\d+\.\d+)\.\d+\b)"); R"(\b(\d+\.\d+)\.\d+\b)");
return McuToolChainPackagePtr{new McuToolChainPackage(settingsHandler, return McuToolchainPackagePtr{new McuToolchainPackage(settingsHandler,
Tr::tr("MSVC Binary directory"), Tr::tr("MSVC Binary directory"),
defaultPath, defaultPath,
{detectionPath}, {detectionPath},
"MsvcToolchain", "MsvcToolchain",
McuToolChainPackage::ToolChainType::MSVC, McuToolchainPackage::ToolchainType::MSVC,
versions, versions,
{}, {},
{}, {},
versionDetector)}; versionDetector)};
} }
McuToolChainPackagePtr createGccToolChainPackage(const SettingsHandler::Ptr &settingsHandler, McuToolchainPackagePtr createGccToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
const QStringList &versions) const QStringList &versions)
{ {
Toolchain *toolChain = McuToolChainPackage::gccToolChain( Toolchain *toolChain = McuToolchainPackage::gccToolchain(
ProjectExplorer::Constants::CXX_LANGUAGE_ID); ProjectExplorer::Constants::CXX_LANGUAGE_ID);
const FilePath detectionPath = FilePath("bin/g++*").withExecutableSuffix(); const FilePath detectionPath = FilePath("bin/g++*").withExecutableSuffix();
@@ -220,19 +220,19 @@ McuToolChainPackagePtr createGccToolChainPackage(const SettingsHandler::Ptr &set
{"--version"}, {"--version"},
R"(\b(\d+\.\d+\.\d+)\b)"); R"(\b(\d+\.\d+\.\d+)\b)");
return McuToolChainPackagePtr{new McuToolChainPackage(settingsHandler, return McuToolchainPackagePtr{new McuToolchainPackage(settingsHandler,
Tr::tr("GCC Toolchain"), Tr::tr("GCC Toolchain"),
defaultPath, defaultPath,
{detectionPath}, {detectionPath},
"GnuToolchain", "GnuToolchain",
McuToolChainPackage::ToolChainType::GCC, McuToolchainPackage::ToolchainType::GCC,
versions, versions,
{}, {},
{}, {},
versionDetector)}; versionDetector)};
} }
McuToolChainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &settingsHandler, McuToolchainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
const QStringList &versions) const QStringList &versions)
{ {
const char envVar[] = "ARMGCC_DIR"; const char envVar[] = "ARMGCC_DIR";
@@ -256,20 +256,20 @@ McuToolChainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &
{"--version"}, {"--version"},
R"(\b(\d+\.\d+\.\d+)\b)"); R"(\b(\d+\.\d+\.\d+)\b)");
return McuToolChainPackagePtr{ return McuToolchainPackagePtr{
new McuToolChainPackage(settingsHandler, new McuToolchainPackage(settingsHandler,
Tr::tr("GNU Arm Embedded Toolchain"), Tr::tr("GNU Arm Embedded Toolchain"),
defaultPath, defaultPath,
{detectionPath}, {detectionPath},
"GNUArmEmbeddedToolchain", // settingsKey "GNUArmEmbeddedToolchain", // settingsKey
McuToolChainPackage::ToolChainType::ArmGcc, // toolchainType McuToolchainPackage::ToolchainType::ArmGcc, // toolchainType
versions, versions,
Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
envVar, // env var envVar, // env var
versionDetector)}; versionDetector)};
} }
McuToolChainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &settingsHandler, McuToolchainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
const QStringList &versions) const QStringList &versions)
{ {
const char envVar[] = "GHS_COMPILER_DIR"; const char envVar[] = "GHS_COMPILER_DIR";
@@ -281,20 +281,20 @@ McuToolChainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &set
{"-help"}, {"-help"},
R"(\bv(\d+\.\d+\.\d+)\b)"); R"(\bv(\d+\.\d+\.\d+)\b)");
return McuToolChainPackagePtr{ return McuToolchainPackagePtr{
new McuToolChainPackage(settingsHandler, new McuToolchainPackage(settingsHandler,
"Green Hills Compiler", "Green Hills Compiler",
defaultPath, defaultPath,
{FilePath("ccv850").withExecutableSuffix()}, // detectionPath {FilePath("ccv850").withExecutableSuffix()}, // detectionPath
"GHSToolchain", // settingsKey "GHSToolchain", // settingsKey
McuToolChainPackage::ToolChainType::GHS, // toolchainType McuToolchainPackage::ToolchainType::GHS, // toolchainType
versions, versions,
Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
envVar, // env var envVar, // env var
versionDetector)}; versionDetector)};
} }
McuToolChainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &settingsHandler, McuToolchainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
const QStringList &versions) const QStringList &versions)
{ {
const char envVar[] = "GHS_ARM_COMPILER_DIR"; const char envVar[] = "GHS_ARM_COMPILER_DIR";
@@ -306,20 +306,20 @@ McuToolChainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &
{"-help"}, {"-help"},
R"(\bv(\d+\.\d+\.\d+)\b)"); R"(\bv(\d+\.\d+\.\d+)\b)");
return McuToolChainPackagePtr{ return McuToolchainPackagePtr{
new McuToolChainPackage(settingsHandler, new McuToolchainPackage(settingsHandler,
"Green Hills Compiler for ARM", "Green Hills Compiler for ARM",
defaultPath, defaultPath,
{FilePath("cxarm").withExecutableSuffix()}, // detectionPath {FilePath("cxarm").withExecutableSuffix()}, // detectionPath
"GHSArmToolchain", // settingsKey "GHSArmToolchain", // settingsKey
McuToolChainPackage::ToolChainType::GHSArm, // toolchainType McuToolchainPackage::ToolchainType::GHSArm, // toolchainType
versions, versions,
Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
envVar, // env var envVar, // env var
versionDetector)}; versionDetector)};
} }
McuToolChainPackagePtr createIarToolChainPackage(const SettingsHandler::Ptr &settingsHandler, McuToolchainPackagePtr createIarToolchainPackage(const SettingsHandler::Ptr &settingsHandler,
const QStringList &versions) const QStringList &versions)
{ {
const char envVar[] = "IAR_ARM_COMPILER_DIR"; const char envVar[] = "IAR_ARM_COMPILER_DIR";
@@ -344,13 +344,13 @@ McuToolChainPackagePtr createIarToolChainPackage(const SettingsHandler::Ptr &set
{"--version"}, {"--version"},
R"(\bV(\d+\.\d+\.\d+)\.\d+\b)"); R"(\bV(\d+\.\d+\.\d+)\.\d+\b)");
return McuToolChainPackagePtr{ return McuToolchainPackagePtr{
new McuToolChainPackage(settingsHandler, new McuToolchainPackage(settingsHandler,
"IAR ARM Compiler", "IAR ARM Compiler",
defaultPath, defaultPath,
{detectionPath}, {detectionPath},
"IARToolchain", // settings key "IARToolchain", // settings key
McuToolChainPackage::ToolChainType::IAR, // toolchainType McuToolchainPackage::ToolchainType::IAR, // toolchainType
versions, versions,
Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
envVar, // env var envVar, // env var
@@ -494,13 +494,13 @@ static McuAbstractTargetFactory::Ptr createFactory(bool isLegacy,
return Legacy::createGhsToolchainPackage(settingsHandler, versions); return Legacy::createGhsToolchainPackage(settingsHandler, versions);
}}, }},
{{"iar"}, {[settingsHandler](const QStringList &versions) { {{"iar"}, {[settingsHandler](const QStringList &versions) {
return Legacy::createIarToolChainPackage(settingsHandler, versions); return Legacy::createIarToolchainPackage(settingsHandler, versions);
}}}, }}},
{{"msvc"}, {[settingsHandler](const QStringList &versions) { {{"msvc"}, {[settingsHandler](const QStringList &versions) {
return Legacy::createMsvcToolChainPackage(settingsHandler, versions); return Legacy::createMsvcToolchainPackage(settingsHandler, versions);
}}}, }}},
{{"gcc"}, {[settingsHandler](const QStringList &versions) { {{"gcc"}, {[settingsHandler](const QStringList &versions) {
return Legacy::createGccToolChainPackage(settingsHandler, versions); return Legacy::createGccToolchainPackage(settingsHandler, versions);
}}}, }}},
{{"arm-greenhills"}, {[settingsHandler](const QStringList &versions) { {{"arm-greenhills"}, {[settingsHandler](const QStringList &versions) {
return Legacy::createGhsArmToolchainPackage(settingsHandler, versions); return Legacy::createGhsArmToolchainPackage(settingsHandler, versions);
@@ -585,7 +585,7 @@ McuSdkRepository targetsFromDescriptions(const QList<McuTargetDescription> &desc
if (isLegacy) { if (isLegacy) {
auto [toolchainPkgs, vendorPkgs]{targetFactory->getAdditionalPackages()}; auto [toolchainPkgs, vendorPkgs]{targetFactory->getAdditionalPackages()};
for (McuToolChainPackagePtr &package : toolchainPkgs) { for (McuToolchainPackagePtr &package : toolchainPkgs) {
mcuPackages.insert(package); mcuPackages.insert(package);
} }
for (McuPackagePtr &package : vendorPkgs) { for (McuPackagePtr &package : vendorPkgs) {

18
src/plugins/mcusupport/mcusupportsdk.h
View File

@@ -15,7 +15,7 @@ class McuAbstractPackage;
class McuPackage; class McuPackage;
class McuSdkRepository; class McuSdkRepository;
class McuTarget; class McuTarget;
class McuToolChainPackage; class McuToolchainPackage;
struct McuTargetDescription; struct McuTargetDescription;
McuPackagePtr createQtForMCUsPackage(const SettingsHandler::Ptr &); McuPackagePtr createQtForMCUsPackage(const SettingsHandler::Ptr &);
@@ -35,16 +35,16 @@ Utils::FilePath kitsPath(const Utils::FilePath &dir);
namespace Legacy { namespace Legacy {
McuPackagePtr createUnsupportedToolChainFilePackage(const SettingsHandler::Ptr &, McuPackagePtr createUnsupportedToolchainFilePackage(const SettingsHandler::Ptr &,
const Utils::FilePath &qtMcuSdkPath); const Utils::FilePath &qtMcuSdkPath);
McuToolChainPackagePtr createUnsupportedToolChainPackage(const SettingsHandler::Ptr &); McuToolchainPackagePtr createUnsupportedToolchainPackage(const SettingsHandler::Ptr &);
McuToolChainPackagePtr createIarToolChainPackage(const SettingsHandler::Ptr &, const QStringList &); McuToolchainPackagePtr createIarToolchainPackage(const SettingsHandler::Ptr &, const QStringList &);
McuToolChainPackagePtr createGccToolChainPackage(const SettingsHandler::Ptr &, const QStringList &); McuToolchainPackagePtr createGccToolchainPackage(const SettingsHandler::Ptr &, const QStringList &);
McuToolChainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &, McuToolchainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &,
const QStringList &); const QStringList &);
McuToolChainPackagePtr createMsvcToolChainPackage(const SettingsHandler::Ptr &, const QStringList &); McuToolchainPackagePtr createMsvcToolchainPackage(const SettingsHandler::Ptr &, const QStringList &);
McuToolChainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &, const QStringList &); McuToolchainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &, const QStringList &);
McuToolChainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &, McuToolchainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &,
const QStringList &); const QStringList &);
McuPackagePtr createBoardSdkPackage(const SettingsHandler::Ptr &, const McuTargetDescription &); McuPackagePtr createBoardSdkPackage(const SettingsHandler::Ptr &, const McuTargetDescription &);

10
src/plugins/mcusupport/mcutarget.cpp
View File

@@ -19,7 +19,7 @@ McuTarget::McuTarget(const QVersionNumber &qulVersion,
const Platform &platform, const Platform &platform,
OS os, OS os,
const Packages &packages, const Packages &packages,
const McuToolChainPackagePtr &toolChainPackage, const McuToolchainPackagePtr &toolChainPackage,
const McuPackagePtr &toolChainFilePackage, const McuPackagePtr &toolChainFilePackage,
int colorDepth) int colorDepth)
: m_qulVersion(qulVersion) : m_qulVersion(qulVersion)
@@ -36,7 +36,7 @@ Packages McuTarget::packages() const
return m_packages; return m_packages;
} }
McuToolChainPackagePtr McuTarget::toolChainPackage() const McuToolchainPackagePtr McuTarget::toolChainPackage() const
{ {
return m_toolChainPackage; return m_toolChainPackage;
} }
@@ -72,10 +72,10 @@ QString McuTarget::desktopCompilerId() const
// for MSVC and MinGW. // for MSVC and MinGW.
if (m_toolChainPackage) { if (m_toolChainPackage) {
switch (m_toolChainPackage->toolchainType()) { switch (m_toolChainPackage->toolchainType()) {
case McuToolChainPackage::ToolChainType::MSVC: case McuToolchainPackage::ToolchainType::MSVC:
return QLatin1String("msvc"); return QLatin1String("msvc");
case McuToolChainPackage::ToolChainType::GCC: case McuToolchainPackage::ToolchainType::GCC:
case McuToolChainPackage::ToolChainType::MinGW: case McuToolchainPackage::ToolchainType::MinGW:
return QLatin1String("gnu"); return QLatin1String("gnu");
default: default:
return QLatin1String("unsupported"); return QLatin1String("unsupported");

8
src/plugins/mcusupport/mcutarget.h
View File

@@ -19,7 +19,7 @@ class InfoLabel;
namespace McuSupport::Internal { namespace McuSupport::Internal {
class McuToolChainPackage; class McuToolchainPackage;
class McuTarget : public QObject class McuTarget : public QObject
{ {
@@ -41,13 +41,13 @@ public:
const Platform &platform, const Platform &platform,
OS os, OS os,
const Packages &packages, const Packages &packages,
const McuToolChainPackagePtr &toolChainPackage, const McuToolchainPackagePtr &toolChainPackage,
const McuPackagePtr &toolChainFilePackage, const McuPackagePtr &toolChainFilePackage,
int colorDepth = UnspecifiedColorDepth); int colorDepth = UnspecifiedColorDepth);
QVersionNumber qulVersion() const; QVersionNumber qulVersion() const;
Packages packages() const; Packages packages() const;
McuToolChainPackagePtr toolChainPackage() const; McuToolchainPackagePtr toolChainPackage() const;
McuPackagePtr toolChainFilePackage() const; McuPackagePtr toolChainFilePackage() const;
Platform platform() const; Platform platform() const;
OS os() const; OS os() const;
@@ -67,7 +67,7 @@ private:
const Platform m_platform; const Platform m_platform;
const OS m_os; const OS m_os;
const Packages m_packages; const Packages m_packages;
McuToolChainPackagePtr m_toolChainPackage; McuToolchainPackagePtr m_toolChainPackage;
McuPackagePtr m_toolChainFilePackage; McuPackagePtr m_toolChainFilePackage;
const int m_colorDepth; const int m_colorDepth;
}; // class McuTarget }; // class McuTarget

40
src/plugins/mcusupport/mcutargetfactory.cpp
View File

@@ -18,11 +18,11 @@
namespace McuSupport::Internal { namespace McuSupport::Internal {
bool isDesktopToolchain(McuToolChainPackage::ToolChainType type) bool isDesktopToolchain(McuToolchainPackage::ToolchainType type)
{ {
return type == McuToolChainPackage::ToolChainType::MSVC return type == McuToolchainPackage::ToolchainType::MSVC
|| type == McuToolChainPackage::ToolChainType::GCC || type == McuToolchainPackage::ToolchainType::GCC
|| type == McuToolChainPackage::ToolChainType::MinGW; || type == McuToolchainPackage::ToolchainType::MinGW;
} }
McuPackageVersionDetector *createVersionDetection(const VersionDetection &versionDetection) McuPackageVersionDetector *createVersionDetection(const VersionDetection &versionDetection)
@@ -82,7 +82,7 @@ QPair<Targets, Packages> McuTargetFactory::createTargets(const McuTargetDescript
if (!toolchain || !toolchainFile) if (!toolchain || !toolchainFile)
continue; continue;
Packages targetPackages = createPackages(desc); Packages targetPackages = createPackages(desc);
McuToolChainPackagePtr toolchainPtr{toolchain}; McuToolchainPackagePtr toolchainPtr{toolchain};
targetPackages.insert({toolchainPtr}); targetPackages.insert({toolchainPtr});
targetPackages.insert({qtForMCUsPackage}); targetPackages.insert({qtForMCUsPackage});
targetPackages.unite({toolchainFile}); targetPackages.unite({toolchainFile});
@@ -141,29 +141,29 @@ McuPackagePtr McuTargetFactory::createPackage(const PackageDescription &pkgDesc)
pkgDesc.type}}; pkgDesc.type}};
} }
McuToolChainPackage *McuTargetFactory::createToolchain( McuToolchainPackage *McuTargetFactory::createToolchain(
const McuTargetDescription::Toolchain &toolchain, const McuTargetDescription::Toolchain &toolchain,
const Utils::FilePath &sourceFile const Utils::FilePath &sourceFile
) )
{ {
const static QMap<QString, McuToolChainPackage::ToolChainType> toolchainTypeMapping{ const static QMap<QString, McuToolchainPackage::ToolchainType> toolchainTypeMapping{
{"iar", McuToolChainPackage::ToolChainType::IAR}, {"iar", McuToolchainPackage::ToolchainType::IAR},
{"keil", McuToolChainPackage::ToolChainType::KEIL}, {"keil", McuToolchainPackage::ToolchainType::KEIL},
{"msvc", McuToolChainPackage::ToolChainType::MSVC}, {"msvc", McuToolchainPackage::ToolchainType::MSVC},
{"gcc", McuToolChainPackage::ToolChainType::GCC}, {"gcc", McuToolchainPackage::ToolchainType::GCC},
{"mingw", McuToolChainPackage::ToolChainType::MinGW}, {"mingw", McuToolchainPackage::ToolchainType::MinGW},
{"armgcc", McuToolChainPackage::ToolChainType::ArmGcc}, {"armgcc", McuToolchainPackage::ToolchainType::ArmGcc},
{"greenhills", McuToolChainPackage::ToolChainType::GHS}, {"greenhills", McuToolchainPackage::ToolchainType::GHS},
{"arm-greenhills", McuToolChainPackage::ToolChainType::GHSArm}, {"arm-greenhills", McuToolchainPackage::ToolchainType::GHSArm},
}; };
const PackageDescription compilerDescription{toolchain.compiler}; const PackageDescription compilerDescription{toolchain.compiler};
McuToolChainPackage::ToolChainType toolchainType McuToolchainPackage::ToolchainType toolchainType
= toolchainTypeMapping.value(toolchain.id, McuToolChainPackage::ToolChainType::Unsupported); = toolchainTypeMapping.value(toolchain.id, McuToolchainPackage::ToolchainType::Unsupported);
if (isDesktopToolchain(toolchainType)) { if (isDesktopToolchain(toolchainType)) {
return new McuToolChainPackage{settingsHandler, return new McuToolchainPackage{settingsHandler,
compilerDescription.label, compilerDescription.label,
compilerDescription.defaultPath, compilerDescription.defaultPath,
compilerDescription.detectionPaths, compilerDescription.detectionPaths,
@@ -189,7 +189,7 @@ McuToolChainPackage *McuTargetFactory::createToolchain(
} }
if (!errorMessage.isEmpty()) { if (!errorMessage.isEmpty()) {
toolchainType = McuToolChainPackage::ToolChainType::Unsupported; toolchainType = McuToolchainPackage::ToolchainType::Unsupported;
if (toolchain.id.isEmpty()) { if (toolchain.id.isEmpty()) {
printMessage(Tr::tr("Toolchain is invalid because %2 in file \"%3\".") printMessage(Tr::tr("Toolchain is invalid because %2 in file \"%3\".")
@@ -203,7 +203,7 @@ McuToolChainPackage *McuTargetFactory::createToolchain(
} }
return new McuToolChainPackage{settingsHandler, return new McuToolchainPackage{settingsHandler,
compilerDescription.label, compilerDescription.label,
compilerDescription.defaultPath, compilerDescription.defaultPath,
compilerDescription.detectionPaths, compilerDescription.detectionPaths,

2
src/plugins/mcusupport/mcutargetfactory.h
View File

@@ -20,7 +20,7 @@ public:
QPair<Targets, Packages> createTargets(const McuTargetDescription &, QPair<Targets, Packages> createTargets(const McuTargetDescription &,
const McuPackagePtr &qtForMCUsPackage) override; const McuPackagePtr &qtForMCUsPackage) override;
Packages createPackages(const McuTargetDescription &); Packages createPackages(const McuTargetDescription &);
McuToolChainPackage *createToolchain(const McuTargetDescription::Toolchain &, const Utils::FilePath &sourceFile = Utils::FilePath()); McuToolchainPackage *createToolchain(const McuTargetDescription::Toolchain &, const Utils::FilePath &sourceFile = Utils::FilePath());
McuPackagePtr createPackage(const PackageDescription &); McuPackagePtr createPackage(const PackageDescription &);
private: private:

12
src/plugins/mcusupport/mcutargetfactorylegacy.cpp
View File

@@ -31,14 +31,14 @@ QPair<Targets, Packages> McuTargetFactory::createTargets(const McuTargetDescript
QHash<QString, McuPackagePtr> freeRTOSPkgs; QHash<QString, McuPackagePtr> freeRTOSPkgs;
Targets mcuTargets; Targets mcuTargets;
Packages packages; Packages packages;
McuToolChainPackagePtr toolchainPackage = getToolchainCompiler(desc.toolchain); McuToolchainPackagePtr toolchainPackage = getToolchainCompiler(desc.toolchain);
McuPackagePtr toolchainFilePackage = getToolchainFile(qtForMcuPath, desc.toolchain.id); McuPackagePtr toolchainFilePackage = getToolchainFile(qtForMcuPath, desc.toolchain.id);
for (int colorDepth : desc.platform.colorDepths) { for (int colorDepth : desc.platform.colorDepths) {
Packages required3rdPartyPkgs; Packages required3rdPartyPkgs;
// Desktop toolchains don't need any additional settings // Desktop toolchains don't need any additional settings
if (toolchainPackage if (toolchainPackage
&& toolchainPackage->toolchainType() && toolchainPackage->toolchainType()
!= McuToolChainPackage::ToolChainType::Unsupported) { != McuToolchainPackage::ToolchainType::Unsupported) {
required3rdPartyPkgs.insert(toolchainPackage); required3rdPartyPkgs.insert(toolchainPackage);
} }
@@ -90,13 +90,13 @@ McuAbstractTargetFactory::AdditionalPackages McuTargetFactory::getAdditionalPack
return {{}, vendorPkgs}; return {{}, vendorPkgs};
} }
McuToolChainPackagePtr McuTargetFactory::getToolchainCompiler( McuToolchainPackagePtr McuTargetFactory::getToolchainCompiler(
const McuTargetDescription::Toolchain &desc) const const McuTargetDescription::Toolchain &desc) const
{ {
auto compilerCreator = toolchainCreators.value(desc.id, [this](const QStringList & /*versions*/) { auto compilerCreator = toolchainCreators.value(desc.id, [this](const QStringList & /*versions*/) {
return McuToolChainPackagePtr{Legacy::createUnsupportedToolChainPackage(settingsHandler)}; return McuToolchainPackagePtr{Legacy::createUnsupportedToolchainPackage(settingsHandler)};
}); });
McuToolChainPackagePtr toolchainPackage = compilerCreator(desc.versions); McuToolchainPackagePtr toolchainPackage = compilerCreator(desc.versions);
return toolchainPackage; return toolchainPackage;
} }
@@ -107,7 +107,7 @@ McuPackagePtr McuTargetFactory::getToolchainFile(const Utils::FilePath &qtForMCU
return toolchainFile; return toolchainFile;
} else { } else {
return McuPackagePtr{ return McuPackagePtr{
Legacy::createUnsupportedToolChainFilePackage(settingsHandler, qtForMCUSdkPath)}; Legacy::createUnsupportedToolchainFilePackage(settingsHandler, qtForMCUSdkPath)};
} }
} }
} // namespace McuSupport::Internal::Legacy } // namespace McuSupport::Internal::Legacy

4
src/plugins/mcusupport/mcutargetfactorylegacy.h
View File

@@ -17,7 +17,7 @@ class McuPackage;
namespace Legacy { namespace Legacy {
using ToolchainCompilerCreator = std::function<McuToolChainPackagePtr(const QStringList &version)>; using ToolchainCompilerCreator = std::function<McuToolchainPackagePtr(const QStringList &version)>;
class McuTargetFactory : public McuAbstractTargetFactory class McuTargetFactory : public McuAbstractTargetFactory
{ {
@@ -31,7 +31,7 @@ public:
const McuPackagePtr &qtForMCUsPackage) override; const McuPackagePtr &qtForMCUsPackage) override;
AdditionalPackages getAdditionalPackages() const override; AdditionalPackages getAdditionalPackages() const override;
McuToolChainPackagePtr getToolchainCompiler(const McuTargetDescription::Toolchain &) const; McuToolchainPackagePtr getToolchainCompiler(const McuTargetDescription::Toolchain &) const;
McuPackagePtr getToolchainFile(const Utils::FilePath &qtForMCUSdkPath, McuPackagePtr getToolchainFile(const Utils::FilePath &qtForMCUSdkPath,
const QString &toolchainName) const; const QString &toolchainName) const;

82
src/plugins/mcusupport/test/unittest.cpp
View File

@@ -210,7 +210,7 @@ auto expandTargetsAndPackages = [](Targets &targets, Packages &packages) {
McuSdkRepository{targets, packages}.expandVariablesAndWildcards(); McuSdkRepository{targets, packages}.expandVariablesAndWildcards();
}; };
void verifyIarToolchain(const McuToolChainPackagePtr &iarToolchainPackage) void verifyIarToolchain(const McuToolchainPackagePtr &iarToolchainPackage)
{ {
ProjectExplorer::ToolchainFactory toolchainFactory; ProjectExplorer::ToolchainFactory toolchainFactory;
Id iarId{BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID}; Id iarId{BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID};
@@ -222,8 +222,8 @@ void verifyIarToolchain(const McuToolChainPackagePtr &iarToolchainPackage)
QCOMPARE(iarToolchainPackage->cmakeVariableName(), TOOLCHAIN_DIR_CMAKE_VARIABLE); QCOMPARE(iarToolchainPackage->cmakeVariableName(), TOOLCHAIN_DIR_CMAKE_VARIABLE);
QCOMPARE(iarToolchainPackage->environmentVariableName(), iarEnvVar); QCOMPARE(iarToolchainPackage->environmentVariableName(), iarEnvVar);
QCOMPARE(iarToolchainPackage->isDesktopToolchain(), false); QCOMPARE(iarToolchainPackage->isDesktopToolchain(), false);
QCOMPARE(iarToolchainPackage->toolChainName(), iar); QCOMPARE(iarToolchainPackage->toolchainName(), iar);
QCOMPARE(iarToolchainPackage->toolchainType(), McuToolChainPackage::ToolChainType::IAR); QCOMPARE(iarToolchainPackage->toolchainType(), McuToolchainPackage::ToolchainType::IAR);
QCOMPARE(iarToolchainPackage->label(), iarLabel); QCOMPARE(iarToolchainPackage->label(), iarLabel);
iarToolchain = iarToolchainPackage->toolChain(cxxLanguageId); iarToolchain = iarToolchainPackage->toolChain(cxxLanguageId);
@@ -232,7 +232,7 @@ void verifyIarToolchain(const McuToolChainPackagePtr &iarToolchainPackage)
QCOMPARE(iarToolchain->detection(), Toolchain::UninitializedDetection); QCOMPARE(iarToolchain->detection(), Toolchain::UninitializedDetection);
} }
void verifyArmGccToolchain(const McuToolChainPackagePtr &armGccPackage, const QStringList &versions) void verifyArmGccToolchain(const McuToolchainPackagePtr &armGccPackage, const QStringList &versions)
{ {
//Fake register and fake detect compiler. //Fake register and fake detect compiler.
ProjectExplorer::ToolchainFactory toolchainFactory; ProjectExplorer::ToolchainFactory toolchainFactory;
@@ -246,46 +246,46 @@ void verifyArmGccToolchain(const McuToolChainPackagePtr &armGccPackage, const QS
QCOMPARE(armGccPackage->cmakeVariableName(), TOOLCHAIN_DIR_CMAKE_VARIABLE); QCOMPARE(armGccPackage->cmakeVariableName(), TOOLCHAIN_DIR_CMAKE_VARIABLE);
QCOMPARE(armGccPackage->environmentVariableName(), armGccEnvVar); QCOMPARE(armGccPackage->environmentVariableName(), armGccEnvVar);
QCOMPARE(armGccPackage->isDesktopToolchain(), false); QCOMPARE(armGccPackage->isDesktopToolchain(), false);
QCOMPARE(armGccPackage->toolChainName(), armGcc); QCOMPARE(armGccPackage->toolchainName(), armGcc);
QCOMPARE(armGccPackage->toolchainType(), McuToolChainPackage::ToolChainType::ArmGcc); QCOMPARE(armGccPackage->toolchainType(), McuToolchainPackage::ToolchainType::ArmGcc);
QCOMPARE(armGccPackage->settingsKey(), armGccDirectorySetting); QCOMPARE(armGccPackage->settingsKey(), armGccDirectorySetting);
QCOMPARE(armGccPackage->versions(), versions); QCOMPARE(armGccPackage->versions(), versions);
// FIXME(piotr.mucko): Re-enable when toolchains retrieval from McuToolChainPackage is unified for arm and iar. // FIXME(piotr.mucko): Re-enable when toolchains retrieval from McuToolchainPackage is unified for arm and iar.
// armToolchain = armGccPackage->toolChain(cxxLanguageId); // armToolchain = armGccPackage->toolChain(cxxLanguageId);
// QVERIFY(armToolchain != nullptr); // QVERIFY(armToolchain != nullptr);
} }
void verifyGccToolchain(const McuToolChainPackagePtr &gccPackage, const QStringList &versions) void verifyGccToolchain(const McuToolchainPackagePtr &gccPackage, const QStringList &versions)
{ {
QVERIFY(gccPackage != nullptr); QVERIFY(gccPackage != nullptr);
QCOMPARE(gccPackage->cmakeVariableName(), ""); QCOMPARE(gccPackage->cmakeVariableName(), "");
QCOMPARE(gccPackage->environmentVariableName(), ""); QCOMPARE(gccPackage->environmentVariableName(), "");
QCOMPARE(gccPackage->isDesktopToolchain(), true); QCOMPARE(gccPackage->isDesktopToolchain(), true);
QCOMPARE(gccPackage->toolChainName(), "gcc"); QCOMPARE(gccPackage->toolchainName(), "gcc");
QCOMPARE(gccPackage->toolchainType(), McuToolChainPackage::ToolChainType::GCC); QCOMPARE(gccPackage->toolchainType(), McuToolchainPackage::ToolchainType::GCC);
QVERIFY(allOf(versions, [&](const QString &v) { return gccPackage->versions().contains(v); })); QVERIFY(allOf(versions, [&](const QString &v) { return gccPackage->versions().contains(v); }));
} }
void verifyMsvcToolchain(const McuToolChainPackagePtr &msvcPackage, const QStringList &versions) void verifyMsvcToolchain(const McuToolchainPackagePtr &msvcPackage, const QStringList &versions)
{ {
QVERIFY(msvcPackage != nullptr); QVERIFY(msvcPackage != nullptr);
QCOMPARE(msvcPackage->cmakeVariableName(), ""); QCOMPARE(msvcPackage->cmakeVariableName(), "");
QCOMPARE(msvcPackage->environmentVariableName(), ""); QCOMPARE(msvcPackage->environmentVariableName(), "");
QCOMPARE(msvcPackage->toolchainType(), McuToolChainPackage::ToolChainType::MSVC); QCOMPARE(msvcPackage->toolchainType(), McuToolchainPackage::ToolchainType::MSVC);
QCOMPARE(msvcPackage->isDesktopToolchain(), true); QCOMPARE(msvcPackage->isDesktopToolchain(), true);
QCOMPARE(msvcPackage->toolChainName(), "msvc"); QCOMPARE(msvcPackage->toolchainName(), "msvc");
QVERIFY(allOf(versions, [&](const QString &v) { return msvcPackage->versions().contains(v); })); QVERIFY(allOf(versions, [&](const QString &v) { return msvcPackage->versions().contains(v); }));
} }
void verifyMingwToolchain(const McuToolChainPackagePtr &mingwPackage, const QStringList &versions) void verifyMingwToolchain(const McuToolchainPackagePtr &mingwPackage, const QStringList &versions)
{ {
QVERIFY(mingwPackage != nullptr); QVERIFY(mingwPackage != nullptr);
QCOMPARE(mingwPackage->cmakeVariableName(), ""); QCOMPARE(mingwPackage->cmakeVariableName(), "");
QCOMPARE(mingwPackage->environmentVariableName(), ""); QCOMPARE(mingwPackage->environmentVariableName(), "");
QCOMPARE(mingwPackage->toolchainType(), McuToolChainPackage::ToolChainType::MinGW); QCOMPARE(mingwPackage->toolchainType(), McuToolchainPackage::ToolchainType::MinGW);
QCOMPARE(mingwPackage->isDesktopToolchain(), true); QCOMPARE(mingwPackage->isDesktopToolchain(), true);
QCOMPARE(mingwPackage->toolChainName(), "mingw"); QCOMPARE(mingwPackage->toolchainName(), "mingw");
QVERIFY(allOf(versions, [&](const QString &v) { return mingwPackage->versions().contains(v); })); QVERIFY(allOf(versions, [&](const QString &v) { return mingwPackage->versions().contains(v); }));
} }
@@ -404,34 +404,34 @@ McuSupportTest::McuSupportTest()
PackageDescription{}, PackageDescription{},
McuTargetDescription::FreeRTOS{}, McuTargetDescription::FreeRTOS{},
} }
, toolchainPackagePtr{new McuToolChainPackage{ , toolchainPackagePtr{new McuToolchainPackage{
settingsMockPtr, settingsMockPtr,
{}, // label {}, // label
{}, // defaultPath {}, // defaultPath
{}, // detectionPath {}, // detectionPath
{}, // settingsKey {}, // settingsKey
McuToolChainPackage::ToolChainType::Unsupported, // toolchain type McuToolchainPackage::ToolchainType::Unsupported, // toolchain type
{}, // versions {}, // versions
{}, // cmake var name {}, // cmake var name
{}, // env var name {}, // env var name
nullptr // version detector nullptr // version detector
}} }}
, armGccToolchainPackagePtr{new McuToolChainPackage{settingsMockPtr, , armGccToolchainPackagePtr{new McuToolchainPackage{settingsMockPtr,
armGccLabel, armGccLabel,
armGccDir, armGccDir,
{}, // validation path {}, // validation path
armGccDirectorySetting, armGccDirectorySetting,
McuToolChainPackage::ToolChainType::ArmGcc, McuToolchainPackage::ToolchainType::ArmGcc,
{armGccVersion}, {armGccVersion},
TOOLCHAIN_DIR_CMAKE_VARIABLE, TOOLCHAIN_DIR_CMAKE_VARIABLE,
armGccEnvVar, armGccEnvVar,
nullptr}} nullptr}}
, iarToolchainPackagePtr{new McuToolChainPackage{settingsMockPtr, , iarToolchainPackagePtr{new McuToolchainPackage{settingsMockPtr,
iarLabel, iarLabel,
iarDir, iarDir,
{}, // validation path {}, // validation path
iarSetting, iarSetting,
McuToolChainPackage::ToolChainType::IAR, McuToolchainPackage::ToolchainType::IAR,
{armGccVersion}, {armGccVersion},
TOOLCHAIN_DIR_CMAKE_VARIABLE, TOOLCHAIN_DIR_CMAKE_VARIABLE,
iarEnvVar, iarEnvVar,
@@ -580,7 +580,7 @@ void McuSupportTest::test_parseToolchainFromJSON()
void McuSupportTest::test_legacy_createIarToolchain() void McuSupportTest::test_legacy_createIarToolchain()
{ {
McuToolChainPackagePtr iarToolchainPackage = Legacy::createIarToolChainPackage(settingsMockPtr, McuToolchainPackagePtr iarToolchainPackage = Legacy::createIarToolchainPackage(settingsMockPtr,
iarVersions); iarVersions);
verifyIarToolchain(iarToolchainPackage); verifyIarToolchain(iarToolchainPackage);
} }
@@ -589,13 +589,13 @@ void McuSupportTest::test_createIarToolchain()
{ {
const auto description = parseDescriptionJson(iar_stm32f469i_discovery_baremetal_json); const auto description = parseDescriptionJson(iar_stm32f469i_discovery_baremetal_json);
McuToolChainPackagePtr iarToolchainPackage{targetFactory.createToolchain(description.toolchain)}; McuToolchainPackagePtr iarToolchainPackage{targetFactory.createToolchain(description.toolchain)};
verifyIarToolchain(iarToolchainPackage); verifyIarToolchain(iarToolchainPackage);
} }
void McuSupportTest::test_legacy_createDesktopGccToolchain() void McuSupportTest::test_legacy_createDesktopGccToolchain()
{ {
McuToolChainPackagePtr gccPackage = Legacy::createGccToolChainPackage(settingsMockPtr, McuToolchainPackagePtr gccPackage = Legacy::createGccToolchainPackage(settingsMockPtr,
{armGccVersion}); {armGccVersion});
verifyGccToolchain(gccPackage, {armGccVersion}); verifyGccToolchain(gccPackage, {armGccVersion});
} }
@@ -603,13 +603,13 @@ void McuSupportTest::test_legacy_createDesktopGccToolchain()
void McuSupportTest::test_createDesktopGccToolchain() void McuSupportTest::test_createDesktopGccToolchain()
{ {
const auto description = parseDescriptionJson(gcc_desktop_json); const auto description = parseDescriptionJson(gcc_desktop_json);
McuToolChainPackagePtr gccPackage{targetFactory.createToolchain(description.toolchain)}; McuToolchainPackagePtr gccPackage{targetFactory.createToolchain(description.toolchain)};
verifyGccToolchain(gccPackage, {}); verifyGccToolchain(gccPackage, {});
} }
void McuSupportTest::test_legacy_createDesktopMsvcToolchain() void McuSupportTest::test_legacy_createDesktopMsvcToolchain()
{ {
McuToolChainPackagePtr msvcPackage = Legacy::createMsvcToolChainPackage(settingsMockPtr, McuToolchainPackagePtr msvcPackage = Legacy::createMsvcToolchainPackage(settingsMockPtr,
{msvcVersion}); {msvcVersion});
verifyMsvcToolchain(msvcPackage, {msvcVersion}); verifyMsvcToolchain(msvcPackage, {msvcVersion});
} }
@@ -617,14 +617,14 @@ void McuSupportTest::test_legacy_createDesktopMsvcToolchain()
void McuSupportTest::test_createDesktopMsvcToolchain() void McuSupportTest::test_createDesktopMsvcToolchain()
{ {
const auto description = parseDescriptionJson(msvc_desktop_json); const auto description = parseDescriptionJson(msvc_desktop_json);
McuToolChainPackagePtr msvcPackage{targetFactory.createToolchain(description.toolchain)}; McuToolchainPackagePtr msvcPackage{targetFactory.createToolchain(description.toolchain)};
verifyMsvcToolchain(msvcPackage, {}); verifyMsvcToolchain(msvcPackage, {});
} }
void McuSupportTest::test_createDesktopMingwToolchain() void McuSupportTest::test_createDesktopMingwToolchain()
{ {
const auto description = parseDescriptionJson(mingw_desktop_json); const auto description = parseDescriptionJson(mingw_desktop_json);
McuToolChainPackagePtr mingwPackage{targetFactory.createToolchain(description.toolchain)}; McuToolchainPackagePtr mingwPackage{targetFactory.createToolchain(description.toolchain)};
verifyMingwToolchain(mingwPackage, {"11.2.0"}); verifyMingwToolchain(mingwPackage, {"11.2.0"});
} }
@@ -635,7 +635,7 @@ void McuSupportTest::test_verifyManuallyCreatedArmGccToolchain()
void McuSupportTest::test_legacy_createArmGccToolchain() void McuSupportTest::test_legacy_createArmGccToolchain()
{ {
McuToolChainPackagePtr armGccPackage = Legacy::createArmGccToolchainPackage(settingsMockPtr, McuToolchainPackagePtr armGccPackage = Legacy::createArmGccToolchainPackage(settingsMockPtr,
{armGccVersion}); {armGccVersion});
verifyArmGccToolchain(armGccPackage, {armGccVersion}); verifyArmGccToolchain(armGccPackage, {armGccVersion});
} }
@@ -656,31 +656,31 @@ void McuSupportTest::test_createArmGccToolchain()
QFETCH(QString, json); QFETCH(QString, json);
const auto description = parseDescriptionJson(json.toLocal8Bit()); const auto description = parseDescriptionJson(json.toLocal8Bit());
McuToolChainPackagePtr armGccPackage{targetFactory.createToolchain(description.toolchain)}; McuToolchainPackagePtr armGccPackage{targetFactory.createToolchain(description.toolchain)};
verifyArmGccToolchain(armGccPackage, description.toolchain.versions); verifyArmGccToolchain(armGccPackage, description.toolchain.versions);
} }
void McuSupportTest::test_mapParsedToolchainIdToCorrespondingType_data() void McuSupportTest::test_mapParsedToolchainIdToCorrespondingType_data()
{ {
QTest::addColumn<McuTargetDescription>("description"); QTest::addColumn<McuTargetDescription>("description");
QTest::addColumn<McuToolChainPackage::ToolChainType>("toolchainType"); QTest::addColumn<McuToolchainPackage::ToolchainType>("toolchainType");
QTest::newRow("armgcc_stm32h750b_discovery_baremetal_json") QTest::newRow("armgcc_stm32h750b_discovery_baremetal_json")
<< parseDescriptionJson(armgcc_stm32h750b_discovery_baremetal_json) << parseDescriptionJson(armgcc_stm32h750b_discovery_baremetal_json)
<< McuToolChainPackage::ToolChainType::ArmGcc; << McuToolchainPackage::ToolchainType::ArmGcc;
QTest::newRow("iar_mimxrt1064_evk_freertos_json") QTest::newRow("iar_mimxrt1064_evk_freertos_json")
<< parseDescriptionJson(iar_mimxrt1064_evk_freertos_json) << parseDescriptionJson(iar_mimxrt1064_evk_freertos_json)
<< McuToolChainPackage::ToolChainType::IAR; << McuToolchainPackage::ToolchainType::IAR;
QTest::newRow("iar_stm32f469i") << parseDescriptionJson(iar_stm32f469i_discovery_baremetal_json) QTest::newRow("iar_stm32f469i") << parseDescriptionJson(iar_stm32f469i_discovery_baremetal_json)
<< McuToolChainPackage::ToolChainType::IAR; << McuToolchainPackage::ToolchainType::IAR;
} }
void McuSupportTest::test_mapParsedToolchainIdToCorrespondingType() void McuSupportTest::test_mapParsedToolchainIdToCorrespondingType()
{ {
QFETCH(McuTargetDescription, description); QFETCH(McuTargetDescription, description);
QFETCH(McuToolChainPackage::ToolChainType, toolchainType); QFETCH(McuToolchainPackage::ToolchainType, toolchainType);
const McuToolChainPackage *toolchain{targetFactory.createToolchain(description.toolchain)}; const McuToolchainPackage *toolchain{targetFactory.createToolchain(description.toolchain)};
QVERIFY(toolchain != nullptr); QVERIFY(toolchain != nullptr);
QCOMPARE(toolchain->toolchainType(), toolchainType); QCOMPARE(toolchain->toolchainType(), toolchainType);
@@ -857,7 +857,7 @@ void McuSupportTest::test_useFallbackPathForToolchainWhenPathFromSettingsIsNotAv
.Times(2) .Times(2)
.WillRepeatedly(Return(FilePath{fallbackDir})); .WillRepeatedly(Return(FilePath{fallbackDir}));
McuToolChainPackage *toolchain = targetFactory.createToolchain(toolchainDescription); McuToolchainPackage *toolchain = targetFactory.createToolchain(toolchainDescription);
QCOMPARE(toolchain->path().toString(), fallbackDir); QCOMPARE(toolchain->path().toString(), fallbackDir);
} }
@@ -882,7 +882,7 @@ void McuSupportTest::test_usePathFromSettingsForToolchainPath()
.WillOnce(Return(FilePath{empty})) // system scope settings .WillOnce(Return(FilePath{empty})) // system scope settings
.WillOnce(Return(FilePath{armGccDir})); // user scope settings .WillOnce(Return(FilePath{armGccDir})); // user scope settings
McuToolChainPackage *toolchain = targetFactory.createToolchain(toolchainDescription); McuToolchainPackage *toolchain = targetFactory.createToolchain(toolchainDescription);
QCOMPARE(toolchain->path().toString(), armGccDir); QCOMPARE(toolchain->path().toString(), armGccDir);
} }
@@ -1312,7 +1312,7 @@ void McuSupportTest::test_passExecutableVersionDetectorToToolchainPackage()
QCOMPARE(description.toolchain.compiler.versionDetection.executableArgs, versionDetectionArgs); QCOMPARE(description.toolchain.compiler.versionDetection.executableArgs, versionDetectionArgs);
QCOMPARE(description.toolchain.compiler.versionDetection.regex, versionRegex); QCOMPARE(description.toolchain.compiler.versionDetection.regex, versionRegex);
McuToolChainPackagePtr toolchain{targetFactory.createToolchain(description.toolchain)}; McuToolchainPackagePtr toolchain{targetFactory.createToolchain(description.toolchain)};
const auto *versionDetector{toolchain->getVersionDetector()}; const auto *versionDetector{toolchain->getVersionDetector()};
QVERIFY(versionDetector != nullptr); QVERIFY(versionDetector != nullptr);
@@ -1333,7 +1333,7 @@ void McuSupportTest::test_legacy_passExecutableVersionDetectorToToolchainPackage
QFETCH(QString, versionRegex); QFETCH(QString, versionRegex);
const McuTargetDescription description = parseDescriptionJson(json.toLocal8Bit()); const McuTargetDescription description = parseDescriptionJson(json.toLocal8Bit());
McuToolChainPackagePtr toolchain{targetFactory.createToolchain(description.toolchain)}; McuToolchainPackagePtr toolchain{targetFactory.createToolchain(description.toolchain)};
const auto *versionDetector{toolchain->getVersionDetector()}; const auto *versionDetector{toolchain->getVersionDetector()};
QVERIFY(versionDetector != nullptr); QVERIFY(versionDetector != nullptr);

6
src/plugins/mcusupport/test/unittest.h
View File

@@ -124,9 +124,9 @@ private:
PackageDescription compilerDescription; PackageDescription compilerDescription;
PackageDescription toochainFileDescription; PackageDescription toochainFileDescription;
McuTargetDescription targetDescription; McuTargetDescription targetDescription;
McuToolChainPackagePtr toolchainPackagePtr; McuToolchainPackagePtr toolchainPackagePtr;
McuToolChainPackagePtr armGccToolchainPackagePtr; McuToolchainPackagePtr armGccToolchainPackagePtr;
McuToolChainPackagePtr iarToolchainPackagePtr; McuToolchainPackagePtr iarToolchainPackagePtr;
PackageMock *armGccToolchainFilePackage{new PackageMock}; PackageMock *armGccToolchainFilePackage{new PackageMock};
McuPackagePtr armGccToolchainFilePackagePtr{armGccToolchainFilePackage}; McuPackagePtr armGccToolchainFilePackagePtr{armGccToolchainFilePackage};
McuTarget::Platform platform; McuTarget::Platform platform;