void ProjectLoadWizard::addBuildConfiguration(QString name, QtVersion *qtversion, QtVersion::QmakeBuildConfig buildConfiguration) { QMakeStep *qmakeStep = m_project->qmakeStep(); MakeStep *makeStep = m_project->makeStep(); bool debug = buildConfiguration & QtVersion::DebugBuild; // Check that bc.name is not already in use if (m_project->buildConfigurations().contains(name)) { int i =1; do { ++i; } while (m_project->buildConfigurations().contains(name + " " + QString::number(i))); name.append(" " + QString::number(i)); } // Add the buildconfiguration m_project->addBuildConfiguration(name); // set some options for qmake and make if (buildConfiguration & QtVersion::BuildAll) // debug_and_release => explicit targets makeStep->setValue(name, "makeargs", QStringList() << (debug ? "debug" : "release")); qmakeStep->setValue(name, "buildConfiguration", int(buildConfiguration)); // Finally set the qt version bool defaultQtVersion = (qtversion == 0); if (defaultQtVersion) m_project->setQtVersion(name, 0); else m_project->setQtVersion(name, qtversion->uniqueId()); }
void QmakeManager::runQMake(ProjectExplorer::Project *p, ProjectExplorer::Node *node) { if (!ProjectExplorerPlugin::saveModifiedFiles()) return; QmakeProject *qmakeProject = qobject_cast<QmakeProject *>(p); QTC_ASSERT(qmakeProject, return); if (!qmakeProject->activeTarget() || !qmakeProject->activeTarget()->activeBuildConfiguration()) return; QmakeBuildConfiguration *bc = static_cast<QmakeBuildConfiguration *>(qmakeProject->activeTarget()->activeBuildConfiguration()); QMakeStep *qs = bc->qmakeStep(); if (!qs) return; //found qmakeStep, now use it qs->setForced(true); if (node != 0 && node != qmakeProject->rootProjectNode()) if (QmakeProFileNode *profile = dynamic_cast<QmakeProFileNode *>(node)) bc->setSubNodeBuild(profile); BuildManager::appendStep(qs, tr("QMake")); bc->setSubNodeBuild(0); }
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); }
void Qt4BuildConfigWidget::importLabelClicked() { if (m_ui->shadowBuildCheckBox->isChecked()) { QString directory = m_ui->shadowBuildDirEdit->path(); if (!directory.isEmpty()) { QtVersionManager *vm = m_pro->qt4ProjectManager()->versionManager(); QString qtPath = vm->findQtVersionFromMakefile(directory); if (!qtPath.isEmpty()) { QtVersion *version = vm->qtVersionForDirectory(qtPath); if (!version) { version = new QtVersion(QFileInfo(qtPath).baseName(), qtPath); vm->addVersion(version); } QtVersion::QmakeBuildConfig qmakeBuildConfig = version->defaultBuildConfig(); qmakeBuildConfig = vm->scanMakefileForQmakeConfig(directory, qmakeBuildConfig); // So we got all the information now apply it... m_pro->setQtVersion(m_buildConfiguration, version->uniqueId()); // Combo box will be updated at the end // Find qmakestep... QMakeStep *qmakeStep = m_pro->qmakeStep(); MakeStep *makeStep = m_pro->makeStep(); qmakeStep->setValue(m_buildConfiguration, "buildConfiguration", int(qmakeBuildConfig)); // Adjust command line arguments, this is ugly as hell // If we are switching to BuildAll we want "release" in there and no "debug" // or "debug" in there and no "release" // If we are switching to not BuildAl we want neither "release" nor "debug" in there QStringList makeCmdArguments = makeStep->value(m_buildConfiguration, "makeargs").toStringList(); bool debug = qmakeBuildConfig & QtVersion::DebugBuild; if (qmakeBuildConfig & QtVersion::BuildAll) { makeCmdArguments.removeAll(debug ? "release" : "debug"); if (!makeCmdArguments.contains(debug ? "debug" : "release")) makeCmdArguments.append(debug ? "debug" : "release"); } else { makeCmdArguments.removeAll("debug"); makeCmdArguments.removeAll("remove"); } makeStep->setValue(m_buildConfiguration, "makeargs", makeCmdArguments); } } } setupQtVersionsComboBox(); }
void AndroidQmakeBuildConfiguration::manifestSaved() { QString androidNdkPlatform = AndroidConfigurations::currentConfig().bestNdkPlatformMatch(AndroidManager::minimumSDK(target())); if (m_androidNdkPlatform == androidNdkPlatform) return; updateCacheAndEmitEnvironmentChanged(); QMakeStep *qs = qmakeStep(); if (!qs) return; qs->setForced(true); BuildManager::buildList(stepList(ProjectExplorer::Constants::BUILDSTEPS_CLEAN)); BuildManager::appendStep(qs, ProjectExplorerPlugin::displayNameForStepId(ProjectExplorer::Constants::BUILDSTEPS_CLEAN)); setSubNodeBuild(0); }
void IosBuildConfiguration::updateQmakeCommand() { QMakeStep *qmakeStepInstance = qmakeStep(); const QString forceOverrideArg("-after"); if (qmakeStepInstance) { QStringList extraArgs = qmakeStepInstance->extraArguments(); // remove old extra arguments. Utils::erase(extraArgs, [forceOverrideArg](const QString& arg) { return arg.startsWith(qmakeIosTeamSettings) || arg.startsWith(qmakeProvisioningProfileSettings) || arg == forceOverrideArg; }); // Set force ovveride qmake switch if (!m_signingIdentifier.isEmpty() ) extraArgs << forceOverrideArg; Core::Id devType = ProjectExplorer::DeviceTypeKitAspect::deviceTypeId(target()->kit()); if (devType == Constants::IOS_DEVICE_TYPE && !m_signingIdentifier.isEmpty()) { if (m_autoManagedSigning) { extraArgs << qmakeIosTeamSettings + m_signingIdentifier; } else { // Get the team id from provisioning profile ProvisioningProfilePtr profile = IosConfigurations::provisioningProfile(m_signingIdentifier); QString teamId; if (profile) teamId = profile->developmentTeam()->identifier(); else qCDebug(iosLog) << "No provisioing profile found for id:"<< m_signingIdentifier; if (!teamId.isEmpty()) { extraArgs << qmakeProvisioningProfileSettings + m_signingIdentifier; extraArgs << qmakeIosTeamSettings + teamId; } else { qCDebug(iosLog) << "Development team unavailable for profile:" << profile; } } } qmakeStepInstance->setExtraArguments(extraArgs); } }
Qt4BuildConfiguration *Qt4BuildConfiguration::setup(Target *t, QString defaultDisplayName, QString displayName, BaseQtVersion::QmakeBuildConfigs qmakeBuildConfiguration, QString additionalArguments, QString directory, bool importing) { // Add the build configuration. Qt4BuildConfiguration *bc = new Qt4BuildConfiguration(t); bc->setDefaultDisplayName(defaultDisplayName); bc->setDisplayName(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); bool enableQmlDebugger = Qt4BuildConfiguration::removeQMLInspectorFromArguments(&additionalArguments); if (!additionalArguments.isEmpty()) qmakeStep->setUserArguments(additionalArguments); if (importing) qmakeStep->setLinkQmlDebuggingLibrary(enableQmlDebugger); bc->setQMakeBuildConfiguration(qmakeBuildConfiguration); if (!directory.isEmpty()) bc->setShadowBuildAndDirectory(directory != t->project()->projectDirectory(), directory); return bc; }
void AndroidPackageCreationWidget::setTargetSDK(const QString &sdk) { AndroidManager::setBuildTargetSDK(m_step->target(), sdk); QmakeBuildConfiguration *bc = qobject_cast<QmakeBuildConfiguration *>(m_step->target()->activeBuildConfiguration()); if (!bc) return; QMakeStep *qs = bc->qmakeStep(); if (!qs) return; qs->setForced(true); BuildManager::buildList(bc->stepList(ProjectExplorer::Constants::BUILDSTEPS_CLEAN), ProjectExplorerPlugin::displayNameForStepId(ProjectExplorer::Constants::BUILDSTEPS_CLEAN)); BuildManager::appendStep(qs, ProjectExplorerPlugin::displayNameForStepId(ProjectExplorer::Constants::BUILDSTEPS_CLEAN)); bc->setSubNodeBuild(0); // Make the buildconfiguration emit a evironmentChanged() signal // TODO find a better way bool use = bc->useSystemEnvironment(); bc->setUseSystemEnvironment(!use); bc->setUseSystemEnvironment(use); }
// 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; }