MerQtVersion* MerTarget::createQtVersion() const { const FileName qmake = FileName::fromString(targetPath() + QLatin1Char('/') + QLatin1String(Constants::MER_WRAPPER_QMAKE)); // Is there a qtversion present for this qmake? BaseQtVersion *qtv = QtVersionManager::qtVersionForQMakeBinary(qmake); if (qtv && !qtv->isValid()) { QtVersionManager::removeVersion(qtv); qtv = 0; } if (!qtv) qtv = new MerQtVersion(qmake, true, targetPath()); //QtVersionFactory::createQtVersionFromQMakePath(qmake, true, targetPath()); QTC_ASSERT(qtv && qtv->type() == QLatin1String(Constants::MER_QT), return 0); MerQtVersion *merqtv = static_cast<MerQtVersion *>(qtv); const QString vmName = m_sdk->virtualMachineName(); merqtv->setVirtualMachineName(vmName); merqtv->setTargetName(m_name); merqtv->setUnexpandedDisplayName( QString::fromLatin1("Qt %1 in %2 %3").arg(qtv->qtVersionString(), vmName, m_name)); return merqtv; }
QList<ProjectExplorer::Task> BaseQtVersion::validateKit(const ProjectExplorer::Kit *k) { QList<ProjectExplorer::Task> result; BaseQtVersion *version = QtKitInformation::qtVersion(k); Q_ASSERT(version == this); ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(k); const QList<ProjectExplorer::Abi> qtAbis = version->qtAbis(); if (tc && !qtAbis.contains(tc->targetAbi())) { QString qtAbiString; foreach (const ProjectExplorer::Abi &qtAbi, qtAbis) { if (!qtAbiString.isEmpty()) qtAbiString.append(QLatin1Char(' ')); qtAbiString.append(qtAbi.toString()); } const QString message = QCoreApplication::translate("BaseQtVersion", "The compiler '%1' (%2) cannot produce code for the Qt version '%3' (%4)."). arg(tc->displayName(), tc->targetAbi().toString(), version->displayName(), qtAbiString); result << ProjectExplorer::Task(ProjectExplorer::Task::Error, message, FileName(), -1, Core::Id(ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM)); } // Abi mismatch
QMakeStepConfig QMakeStep::deducedArguments() const { ProjectExplorer::Kit *kit = target()->kit(); QMakeStepConfig config; ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(kit); ProjectExplorer::Abi targetAbi; if (tc) targetAbi = tc->targetAbi(); BaseQtVersion *version = QtKitInformation::qtVersion(target()->kit()); config.archConfig = QMakeStepConfig::targetArchFor(targetAbi, version); config.osType = QMakeStepConfig::osTypeFor(targetAbi, version); if (linkQmlDebuggingLibrary() && version && version->qtVersion().majorVersion >= 5) config.linkQmlDebuggingQQ2 = true; if (useQtQuickCompiler() && version) config.useQtQuickCompiler = true; if (separateDebugInfo()) config.separateDebugInfo = true; return config; }
// Update with results of terminated helper build void QtOptionsPageWidget::debuggingHelperBuildFinished(int qtVersionId, const QString &output, DebuggingHelperBuildTask::Tools tools) { const int index = findVersionById(m_versions, qtVersionId); if (index == -1) return; // Oops, somebody managed to delete the version BaseQtVersion *version = m_versions.at(index); // Update item view QTreeWidgetItem *item = treeItemForIndex(index); QTC_ASSERT(item, return); DebuggingHelperBuildTask::Tools buildFlags = item->data(0, BuildRunningRole).value<DebuggingHelperBuildTask::Tools>(); buildFlags &= ~tools; item->setData(0, BuildRunningRole, QVariant::fromValue(buildFlags)); item->setData(0, BuildLogRole, output); bool success = true; if (tools & DebuggingHelperBuildTask::GdbDebugging) success &= version->hasGdbDebuggingHelper(); if (tools & DebuggingHelperBuildTask::QmlDebugging) success &= version->hasQmlDebuggingLibrary(); if (tools & DebuggingHelperBuildTask::QmlDump) success &= version->hasQmlDump(); if (tools & DebuggingHelperBuildTask::QmlObserver) success &= version->hasQmlObserver(); if (!success) showDebuggingBuildLog(item); updateDebuggingHelperUi(); }
QVariant QtKitInformation::defaultValue(ProjectExplorer::Kit *k) const { Q_UNUSED(k); // find "Qt in PATH": QList<BaseQtVersion *> versionList = QtVersionManager::unsortedVersions(); BaseQtVersion *result = findOrDefault(versionList, equal(&BaseQtVersion::autodetectionSource, QString::fromLatin1("PATH"))); if (result) return result->uniqueId(); // Legacy: Check for system qmake path: Remove in 3.5 (or later): // This check is expensive as it will potentially run binaries (qmake --version)! const FileName qmakePath = BuildableHelperLibrary::findSystemQt(Utils::Environment::systemEnvironment()); if (!qmakePath.isEmpty()) { result = findOrDefault(versionList, equal(&BaseQtVersion::qmakeCommand, qmakePath)); if (result) return result->uniqueId(); } // Use *any* desktop Qt: result = findOrDefault(versionList, equal(&BaseQtVersion::type, QString::fromLatin1(QtSupport::Constants::DESKTOPQT))); return result ? result->uniqueId() : -1; }
QList<Task> MerQtVersion::validateKit(const Kit *kit) { QList<Task> result = BaseQtVersion::validateKit(kit); if (!result.isEmpty()) return result; BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(kit); QTC_ASSERT(version == this, return result); ToolChain *tc = ToolChainKitInformation::toolChain(kit); if (!tc) { const QString message = QCoreApplication::translate("QtVersion", "No available toolchains found to build " "for Qt version '%1'.").arg(version->displayName()); result << Task(Task::Error, message, Utils::FileName(), -1, Core::Id(ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM)); } else if (!MerSdkManager::validateKit(kit)) { const QString message = QCoreApplication::translate("QtVersion", "This Qt version '%1' does not match Mer SDK or toolchain."). arg(version->displayName()); result << Task(Task::Error, message, Utils::FileName(), -1, Core::Id(ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM)); } return result; }
QList<ProjectExplorer::Task> QtKitInformation::validate(const ProjectExplorer::Kit *k) const { QList<ProjectExplorer::Task> result; QTC_ASSERT(QtVersionManager::instance()->isLoaded(), return result); BaseQtVersion *version = qtVersion(k); if (!version) return result; return version->validateKit(k); }
BaseQtVersion *QtVersionFactory::createQtVersionFromLegacySettings(const QString &qmakePath, int id, QSettings *s) { BaseQtVersion *v = createQtVersionFromQMakePath(qmakePath); if (!v) return 0; v->setId(id); v->setDisplayName(s->value("Name").toString()); v->restoreLegacySettings(s); return v; }
// Add changed/added items: foreach (int a, toAdd) { BaseQtVersion *version = QtVersionManager::version(a)->clone(); m_versions.append(version); QTreeWidgetItem *item = new QTreeWidgetItem; item->setText(0, version->displayName()); item->setText(1, version->qmakeCommand().toUserOutput()); item->setData(0, VersionIdRole, version->uniqueId()); item->setData(0, ToolChainIdRole, defaultToolChainId(version)); const ValidityInfo info = validInformation(version); item->setIcon(0, info.icon); // Insert in the right place: QTreeWidgetItem *parent = version->isAutodetected()? m_autoItem : m_manualItem; for (int i = 0; i < parent->childCount(); ++i) { BaseQtVersion *currentVersion = m_versions.at(indexForTreeItem(parent->child(i))); if (currentVersion->qtVersion() > version->qtVersion()) continue; parent->insertChild(i, item); parent = 0; break; } if (parent) parent->addChild(item); }
void Qt4BuildConfiguration::setShadowBuildAndDirectory(bool shadowBuild, const QString &buildDirectory) { BaseQtVersion *version = QtKitInformation::qtVersion(target()->kit()); QString directoryToSet = buildDirectory; bool toSet = (shadowBuild && version && version->isValid() && version->supportsShadowBuilds()); if (m_shadowBuild == toSet && m_buildDirectory == directoryToSet) return; m_shadowBuild = toSet; m_buildDirectory = directoryToSet; emitBuildDirectoryChanged(); emitProFileEvaluateNeeded(); }
std::unique_ptr<QmakeProFileNode> QmakeNodeTreeBuilder::buildTree(QmakeProject *project) { // Remove qmake implementation details that litter up the project data: Target *t = project->activeTarget(); Kit *k = t ? t->kit() : KitManager::defaultKit(); BaseQtVersion *qt = k ? QtKitInformation::qtVersion(k) : nullptr; const FileNameList toExclude = qt ? qt->directoriesToIgnoreInProjectTree() : FileNameList(); auto root = std::make_unique<QmakeProFileNode>(project, project->projectFilePath(), project->rootProFile()); createTree(project->rootProFile(), root.get(), toExclude); return root; }
void QmakeBuildConfigurationFactory::configureBuildConfiguration(Target *parent, QmakeBuildConfiguration *bc, const QmakeBuildInfo *qmakeInfo) const { BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(parent->kit()); BaseQtVersion::QmakeBuildConfigs config = version->defaultBuildConfig(); if (qmakeInfo->buildType == BuildConfiguration::Debug) config |= QtSupport::BaseQtVersion::DebugBuild; else config &= ~QtSupport::BaseQtVersion::DebugBuild; bc->setDefaultDisplayName(qmakeInfo->displayName); bc->setDisplayName(qmakeInfo->displayName); BuildStepList *buildSteps = bc->stepList(Core::Id(ProjectExplorer::Constants::BUILDSTEPS_BUILD)); BuildStepList *cleanSteps = bc->stepList(Core::Id(ProjectExplorer::Constants::BUILDSTEPS_CLEAN)); Q_ASSERT(buildSteps); Q_ASSERT(cleanSteps); QMakeStep *qmakeStep = new QMakeStep(buildSteps); buildSteps->insertStep(0, qmakeStep); MakeStep *makeStep = new MakeStep(buildSteps); buildSteps->insertStep(1, makeStep); MakeStep *cleanStep = new MakeStep(cleanSteps); cleanStep->setClean(true); cleanStep->setUserArguments(QLatin1String("clean")); cleanSteps->insertStep(0, cleanStep); QString additionalArguments = qmakeInfo->additionalArguments; if (!additionalArguments.isEmpty()) qmakeStep->setUserArguments(additionalArguments); qmakeStep->setLinkQmlDebuggingLibrary(qmakeInfo->config.linkQmlDebuggingQQ2); qmakeStep->setSeparateDebugInfo(qmakeInfo->config.separateDebugInfo); qmakeStep->setUseQtQuickCompiler(qmakeInfo->config.useQtQuickCompiler); bc->setQMakeBuildConfiguration(config); Utils::FileName directory = qmakeInfo->buildDirectory; if (directory.isEmpty()) { directory = defaultBuildDirectory(parent->project()->projectFilePath().toString(), parent->kit(), qmakeInfo->displayName, bc->buildType()); } bc->setBuildDirectory(directory); }
QList<Task> BaseQtVersion::validateKit(const Kit *k) { QList<Task> result; BaseQtVersion *version = QtKitInformation::qtVersion(k); Q_ASSERT(version == this); const QList<Abi> qtAbis = version->qtAbis(); if (qtAbis.isEmpty()) // No need to test if Qt does not know anyway... return result; ToolChain *tc = ToolChainKitInformation::toolChain(k); if (tc) { Abi targetAbi = tc->targetAbi(); bool fuzzyMatch = false; bool fullMatch = false; QString qtAbiString; foreach (const Abi &qtAbi, qtAbis) { if (!qtAbiString.isEmpty()) qtAbiString.append(QLatin1Char(' ')); qtAbiString.append(qtAbi.toString()); if (!fullMatch) fullMatch = (targetAbi == qtAbi); if (!fuzzyMatch) fuzzyMatch = targetAbi.isCompatibleWith(qtAbi); } QString message; if (!fullMatch) { if (!fuzzyMatch) message = QCoreApplication::translate("BaseQtVersion", "The compiler '%1' (%2) cannot produce code for the Qt version '%3' (%4)."); else message = QCoreApplication::translate("BaseQtVersion", "The compiler '%1' (%2) may not produce code compatible with the Qt version '%3' (%4)."); message = message.arg(tc->displayName(), targetAbi.toString(), version->displayName(), qtAbiString); result << Task(fuzzyMatch ? Task::Warning : Task::Error, message, FileName(), -1, ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM); } } return result; }
QStringList QmakeBuildConfiguration::configCommandLineArguments() const { QStringList result; BaseQtVersion *version = QtKitInformation::qtVersion(target()->kit()); BaseQtVersion::QmakeBuildConfigs defaultBuildConfiguration = version ? version->defaultBuildConfig() : BaseQtVersion::QmakeBuildConfigs(BaseQtVersion::DebugBuild | BaseQtVersion::BuildAll); BaseQtVersion::QmakeBuildConfigs userBuildConfiguration = m_qmakeBuildConfiguration; if ((defaultBuildConfiguration & BaseQtVersion::BuildAll) && !(userBuildConfiguration & BaseQtVersion::BuildAll)) result << QLatin1String("CONFIG-=debug_and_release"); if (!(defaultBuildConfiguration & BaseQtVersion::BuildAll) && (userBuildConfiguration & BaseQtVersion::BuildAll)) result << QLatin1String("CONFIG+=debug_and_release"); if ((defaultBuildConfiguration & BaseQtVersion::DebugBuild) && !(userBuildConfiguration & BaseQtVersion::DebugBuild)) result << QLatin1String("CONFIG+=release"); if (!(defaultBuildConfiguration & BaseQtVersion::DebugBuild) && (userBuildConfiguration & BaseQtVersion::DebugBuild)) result << QLatin1String("CONFIG+=debug"); return result; }
QList<BuildConfigurationInfo> Qt4BuildConfigurationFactory::availableBuildConfigurations(const Kit *k, const QString &proFilePath) { QList<BuildConfigurationInfo> infoList; BaseQtVersion *version = QtKitInformation::qtVersion(k); if (!version || !version->isValid()) return infoList; BaseQtVersion::QmakeBuildConfigs config = version->defaultBuildConfig() | QtSupport::BaseQtVersion::DebugBuild; BuildConfigurationInfo info = BuildConfigurationInfo(config, QString(), QString(), false); info.directory = Qt4Project::shadowBuildDirectory(proFilePath, k, buildConfigurationDisplayName(info)); infoList.append(info); info.buildConfig = config ^ BaseQtVersion::DebugBuild; info.directory = Qt4Project::shadowBuildDirectory(proFilePath, k, buildConfigurationDisplayName(info)); infoList.append(info); return infoList; }
QVariant QtKitInformation::defaultValue(ProjectExplorer::Kit *k) const { Q_UNUSED(k); // find "Qt in PATH": Utils::FileName qmake = Utils::BuildableHelperLibrary::findSystemQt(Utils::Environment::systemEnvironment()); if (qmake.isEmpty()) return -1; QList<BaseQtVersion *> versionList = QtVersionManager::versions(); BaseQtVersion *fallBack = 0; foreach (BaseQtVersion *v, versionList) { if (qmake == v->qmakeCommand()) return v->uniqueId(); if (v->type() == QLatin1String(QtSupport::Constants::DESKTOPQT) && !fallBack) fallBack = v; } if (fallBack) return fallBack->uniqueId(); return -1; }
void MaemoQemuManager::startRuntime() { m_userTerminated = false; Project *p = SessionManager::startupProject(); if (!p) return; BaseQtVersion *version; if (!targetUsesMatchingRuntimeConfig(p->activeTarget(), &version)) { qWarning("Strange: Qemu button was enabled, but target does not match."); return; } m_runningQtId = version->uniqueId(); const MaemoQemuRuntime rt = m_runtimes.value(version->uniqueId()); m_qemuProcess->setProcessEnvironment(rt.environment()); m_qemuProcess->setWorkingDirectory(rt.m_root); m_qemuProcess->start(rt.m_bin % QLatin1Char(' ') % rt.m_args); if (!m_qemuProcess->waitForStarted()) return; emit qemuProcessStatus(QemuStarting); connect(m_qemuAction, SIGNAL(triggered()), this, SLOT(terminateRuntime())); disconnect(m_qemuAction, SIGNAL(triggered()), this, SLOT(startRuntime())); }
BuildConfiguration *Qt4BuildConfigurationFactory::create(Target *parent, const Core::Id id, const QString &name) { if (!canCreate(parent, id)) return 0; BaseQtVersion *version = QtKitInformation::qtVersion(parent->kit()); Q_ASSERT(version); bool ok = true; QString buildConfigurationName = name; if (buildConfigurationName.isNull()) buildConfigurationName = QInputDialog::getText(0, tr("New Configuration"), tr("New configuration name:"), QLineEdit::Normal, version->displayName(), &ok); buildConfigurationName = buildConfigurationName.trimmed(); if (!ok || buildConfigurationName.isEmpty()) return 0; //: Debug build configuration. We recommend not translating it. QString defaultFirstName = tr("%1 Debug").arg(version->displayName()).trimmed(); QString customFirstName; if (buildConfigurationName != version->displayName()) customFirstName = tr("%1 Debug").arg(buildConfigurationName).trimmed(); //: Release build configuration. We recommend not translating it. QString defaultSecondName = tr("%1 Release").arg(version->displayName()).trimmed(); QString customSecondName; if (buildConfigurationName != version->displayName()) customSecondName = tr("%1 Release").arg(buildConfigurationName).trimmed(); BaseQtVersion::QmakeBuildConfigs config = version->defaultBuildConfig() | QtSupport::BaseQtVersion::DebugBuild; BuildConfiguration *bc = Qt4BuildConfiguration::setup(parent, defaultFirstName, customFirstName, config, QString(), QString(), false); config = config ^ BaseQtVersion::DebugBuild; parent->addBuildConfiguration( Qt4BuildConfiguration::setup(parent, defaultSecondName, customSecondName, config, QString(), QString(), false)); return bc; }
// Returns true if both are equal. QmakeBuildConfiguration::MakefileState QmakeBuildConfiguration::compareToImportFrom(const QString &makefile, QString *errorString) { const QLoggingCategory &logs = MakeFileParse::logging(); qCDebug(logs) << "QMakeBuildConfiguration::compareToImport"; QMakeStep *qs = qmakeStep(); MakeFileParse parse(makefile); if (parse.makeFileState() == MakeFileParse::MakefileMissing) { qCDebug(logs) << "**Makefile missing"; return MakefileMissing; } if (parse.makeFileState() == MakeFileParse::CouldNotParse) { qCDebug(logs) << "**Makefile incompatible"; if (errorString) *errorString = tr("Could not parse Makefile."); return MakefileIncompatible; } if (!qs) { qCDebug(logs) << "**No qmake step"; return MakefileMissing; } BaseQtVersion *version = QtKitInformation::qtVersion(target()->kit()); if (!version) { qCDebug(logs) << "**No qt version in kit"; return MakefileForWrongProject; } if (parse.srcProFile() != qs->project()->projectFilePath().toString()) { qCDebug(logs) << "**Different profile used to generate the Makefile:" << parse.srcProFile() << " expected profile:" << qs->project()->projectFilePath(); if (errorString) *errorString = tr("The Makefile is for a different project."); return MakefileIncompatible; } if (version->qmakeCommand() != parse.qmakePath()) { qCDebug(logs) << "**Different Qt versions, buildconfiguration:" << version->qmakeCommand().toString() << " Makefile:"<< parse.qmakePath().toString(); return MakefileForWrongProject; } // same qtversion BaseQtVersion::QmakeBuildConfigs buildConfig = parse.effectiveBuildConfig(version->defaultBuildConfig()); if (qmakeBuildConfiguration() != buildConfig) { qCDebug(logs) << "**Different qmake buildconfigurations buildconfiguration:" << qmakeBuildConfiguration() << " Makefile:" << buildConfig; if (errorString) *errorString = tr("The build type has changed."); return MakefileIncompatible; } // The qmake Build Configuration are the same, // now compare arguments lists // we have to compare without the spec/platform cmd argument // and compare that on its own QString workingDirectory = QFileInfo(makefile).absolutePath(); QStringList actualArgs; QString userArgs = qs->userArguments(); // This copies the settings from userArgs to actualArgs (minus some we // are not interested in), splitting them up into individual strings: extractSpecFromArguments(&userArgs, workingDirectory, version, &actualArgs); FileName actualSpec = qs->mkspec(); QString qmakeArgs = parse.unparsedArguments(); QStringList parsedArgs; FileName parsedSpec = extractSpecFromArguments(&qmakeArgs, workingDirectory, version, &parsedArgs); qCDebug(logs) << " Actual args:" << actualArgs; qCDebug(logs) << " Parsed args:" << parsedArgs; qCDebug(logs) << " Actual spec:" << actualSpec.toString(); qCDebug(logs) << " Parsed spec:" << parsedSpec.toString(); qCDebug(logs) << " Actual config:" << qs->deducedArguments(); qCDebug(logs) << " Parsed config:" << parse.config(); // Comparing the sorted list is obviously wrong // Though haven written a more complete version // that managed had around 200 lines and yet faild // to be actually foolproof at all, I think it's // not feasible without actually taking the qmake // command line parsing code // Things, sorting gets wrong: // parameters to positional parameters matter // e.g. -o -spec is different from -spec -o // -o 1 -spec 2 is diffrent from -spec 1 -o 2 // variable assignment order matters // variable assignment vs -after // -norecursive vs. recursive actualArgs.sort(); parsedArgs.sort(); if (actualArgs != parsedArgs) { qCDebug(logs) << "**Mismatched args"; if (errorString) *errorString = tr("The qmake arguments have changed."); return MakefileIncompatible; } if (parse.config() != qs->deducedArguments()) { qCDebug(logs) << "**Mismatched config"; if (errorString) *errorString = tr("The qmake arguments have changed."); return MakefileIncompatible; } // Specs match exactly if (actualSpec == parsedSpec) { qCDebug(logs) << "**Matched specs (1)"; return MakefileMatches; } // Actual spec is the default one // qDebug() << "AS vs VS" << actualSpec << version->mkspec(); if ((actualSpec == version->mkspec() || actualSpec == FileName::fromLatin1("default")) && (parsedSpec == version->mkspec() || parsedSpec == FileName::fromLatin1("default") || parsedSpec.isEmpty())) { qCDebug(logs) << "**Matched specs (2)"; return MakefileMatches; } qCDebug(logs) << "**Incompatible specs"; if (errorString) *errorString = tr("The mkspec has changed."); return MakefileIncompatible; }
// Returns true if both are equal. Qt4BuildConfiguration::MakefileState Qt4BuildConfiguration::compareToImportFrom(const QString &makefile) { QMakeStep *qs = qmakeStep(); if (QFileInfo(makefile).exists() && qs) { FileName qmakePath = QtVersionManager::findQMakeBinaryFromMakefile(makefile); BaseQtVersion *version = QtKitInformation::qtVersion(target()->kit()); if (!version) return MakefileForWrongProject; if (version->qmakeCommand() == qmakePath) { // same qtversion QPair<BaseQtVersion::QmakeBuildConfigs, QString> result = QtVersionManager::scanMakeFile(makefile, version->defaultBuildConfig()); if (qmakeBuildConfiguration() == result.first) { // The qmake Build Configuration are the same, // now compare arguments lists // we have to compare without the spec/platform cmd argument // and compare that on its own QString workingDirectory = QFileInfo(makefile).absolutePath(); QStringList actualArgs; QString userArgs = qs->userArguments(); // This copies the settings from userArgs to actualArgs (minus some we // are not interested in), splitting them up into individual strings: extractSpecFromArguments(&userArgs, workingDirectory, version, &actualArgs); actualArgs = qs->deducedArguments() + actualArgs + qs->deducedArgumentsAfter(); FileName actualSpec = qs->mkspec(); QString qmakeArgs = result.second; QStringList parsedArgs; FileName parsedSpec = extractSpecFromArguments(&qmakeArgs, workingDirectory, version, &parsedArgs); if (debug) { qDebug() << "Actual args:" << actualArgs; qDebug() << "Parsed args:" << parsedArgs; qDebug() << "Actual spec:" << actualSpec.toString(); qDebug() << "Parsed spec:" << parsedSpec.toString(); } // Comparing the sorted list is obviously wrong // Though haven written a more complete version // that managed had around 200 lines and yet faild // to be actually foolproof at all, I think it's // not feasible without actually taking the qmake // command line parsing code // Things, sorting gets wrong: // parameters to positional parameters matter // e.g. -o -spec is different from -spec -o // -o 1 -spec 2 is diffrent from -spec 1 -o 2 // variable assignment order matters // variable assignment vs -after // -norecursive vs. recursive actualArgs.sort(); parsedArgs.sort(); if (actualArgs == parsedArgs) { // Specs match exactly if (actualSpec == parsedSpec) return MakefileMatches; // Actual spec is the default one // qDebug() << "AS vs VS" << actualSpec << version->mkspec(); if ((actualSpec == version->mkspec() || actualSpec == FileName::fromString(QLatin1String("default"))) && (parsedSpec == version->mkspec() || parsedSpec == FileName::fromString(QLatin1String("default")) || parsedSpec.isEmpty())) return MakefileMatches; } return MakefileIncompatible; } else { if (debug) qDebug() << "different qmake buildconfigurations buildconfiguration:" << qmakeBuildConfiguration() << " Makefile:" << result.first; return MakefileIncompatible; } } else { if (debug) qDebug() << "different Qt versions, buildconfiguration:" << version->qmakeCommand().toString() << " Makefile:"<< qmakePath.toString(); return MakefileForWrongProject; } } return MakefileMissing; }
foreach (const int id, changed) { BaseQtVersion *v = mgr->version(id); int pos = findQtVersion(id); QTC_CHECK(pos >= 0); m_combo->setItemText(pos, v->displayName()); }
bool Qt4BuildConfiguration::supportsShadowBuilds() { BaseQtVersion *version = QtKitInformation::qtVersion(target()->kit()); return !version || version->supportsShadowBuilds(); }