bool IosPresetBuildStep::init(QList<const BuildStep *> &earlierSteps) { BuildConfiguration *bc = buildConfiguration(); if (!bc) bc = target()->activeBuildConfiguration(); ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); pp->setWorkingDirectory(bc->buildDirectory().toString()); Utils::Environment env = bc->environment(); Utils::Environment::setupEnglishOutput(&env); pp->setEnvironment(env); pp->setCommand(command()); pp->setArguments(Utils::QtcProcess::joinArgs(arguments())); pp->resolveAll(); // If we are cleaning, then build can fail with an error code, but that doesn't mean // we should stop the clean queue // That is mostly so that rebuild works on an already clean project setIgnoreReturnValue(m_clean); setOutputParser(target()->kit()->createOutputParser()); if (outputParser()) outputParser()->setWorkingDirectory(pp->effectiveWorkingDirectory()); return AbstractProcessStep::init(earlierSteps); }
bool QMakeStep::init() { QmakeBuildConfiguration *qt4bc = qmakeBuildConfiguration(); const QtSupport::BaseQtVersion *qtVersion = QtSupport::QtKitInformation::qtVersion(target()->kit()); if (!qtVersion) return false; QString args = allArguments(); QString workingDirectory; if (qt4bc->subNodeBuild()) workingDirectory = qt4bc->subNodeBuild()->buildDir(); else workingDirectory = qt4bc->buildDirectory().toString(); FileName program = qtVersion->qmakeCommand(); QString makefile = workingDirectory; if (qt4bc->subNodeBuild()) { if (!qt4bc->subNodeBuild()->makefile().isEmpty()) makefile.append(qt4bc->subNodeBuild()->makefile()); else makefile.append(QLatin1String("/Makefile")); } else if (!qt4bc->makefile().isEmpty()) { makefile.append(QLatin1Char('/')); makefile.append(qt4bc->makefile()); } else { makefile.append(QLatin1String("/Makefile")); } // Check whether we need to run qmake bool makefileOutDated = (qt4bc->compareToImportFrom(makefile) != QmakeBuildConfiguration::MakefileMatches); if (m_forced || makefileOutDated) m_needToRunQMake = true; m_forced = false; ProcessParameters *pp = processParameters(); pp->setMacroExpander(qt4bc->macroExpander()); pp->setWorkingDirectory(workingDirectory); pp->setCommand(program.toString()); pp->setArguments(args); pp->setEnvironment(qt4bc->environment()); pp->resolveAll(); setOutputParser(new QMakeParser); QmakeProFileNode *node = static_cast<QmakeProject *>(qt4bc->target()->project())->rootQmakeProjectNode(); if (qt4bc->subNodeBuild()) node = qt4bc->subNodeBuild(); QString proFile = node->path(); m_tasks = qtVersion->reportIssues(proFile, workingDirectory); qSort(m_tasks); m_scriptTemplate = node->projectType() == ScriptTemplate; return AbstractProcessStep::init(); }
bool DMakeStep::init(QList<const BuildStep *> &earlierSteps) { BuildConfiguration *bc = buildConfiguration(); if (!bc) bc = target()->activeBuildConfiguration(); m_tasks.clear(); ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ToolChain::Language::Cxx); if (!tc) { m_tasks.append(Task(Task::Error, tr("Qt Creator needs a compiler set up to build. Configure a compiler in the kit options."), Utils::FileName(), -1, Core::Id(ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM))); return true; // otherwise the tasks will not get reported } ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); pp->setWorkingDirectory(bc->buildDirectory().toString()); Utils::Environment env = bc->environment(); // Force output to english for the parsers. Do this here and not in the toolchain's // addToEnvironment() to not screw up the users run environment. env.set(QLatin1String("LC_ALL"), QLatin1String("C")); pp->setEnvironment(env); pp->setCommand(makeCommand(bc->environment())); pp->setArguments(allArguments()); pp->resolveAll(); setOutputParser(new GnuMakeParser()); IOutputParser *parser = target()->kit()->createOutputParser(); if (parser) appendOutputParser(parser); outputParser()->setWorkingDirectory(pp->effectiveWorkingDirectory()); return AbstractProcessStep::init(earlierSteps); }
bool MakeStep::init() { CMakeBuildConfiguration *bc = cmakeBuildConfiguration(); QString arguments = Utils::QtcProcess::joinArgs(m_buildTargets); Utils::QtcProcess::addArgs(&arguments, additionalArguments()); setIgnoreReturnValue(m_clean); ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); pp->setEnvironment(bc->environment()); pp->setWorkingDirectory(bc->buildDirectory()); if (bc->toolChain()) pp->setCommand(bc->toolChain()->makeCommand()); else pp->setCommand(QLatin1String("make")); pp->setArguments(arguments); setOutputParser(new ProjectExplorer::GnuMakeParser()); if (bc->toolChain()) appendOutputParser(bc->toolChain()->outputParser()); outputParser()->setWorkingDirectory(pp->effectiveWorkingDirectory()); return AbstractProcessStep::init(); }
bool MerLocalRsyncDeployStep::init() { Qt4ProjectManager::Qt4BuildConfiguration *bc = qobject_cast<Qt4ProjectManager::Qt4BuildConfiguration*>(buildConfiguration()); if (!bc) bc = qobject_cast<Qt4ProjectManager::Qt4BuildConfiguration*>(target()->activeBuildConfiguration()); if (!bc) { addOutput(tr("Cannot deploy: No active build configuration."), ErrorMessageOutput); return false; } const MerSdk *const merSdk = MerSdkKitInformation::sdk(target()->kit()); if (!merSdk) { addOutput(tr("Cannot deploy: Missing MerSdk information in the kit"),ErrorMessageOutput); return false; } const QString target = MerTargetKitInformation::targetName(this->target()->kit()); if (target.isEmpty()) { addOutput(tr("Cannot deploy: Missing MerTarget information in the kit"),ErrorMessageOutput); return false; } IDevice::ConstPtr device = DeviceKitInformation::device(this->target()->kit()); //TODO: HACK if (device.isNull() && DeviceTypeKitInformation::deviceTypeId(this->target()->kit()) != Constants::MER_DEVICE_TYPE_ARM) { addOutput(tr("Cannot deploy: Missing MerDevice information in the kit"),ErrorMessageOutput); return false; } const QString projectDirectory = bc->shadowBuild() ? bc->shadowBuildDirectory() : project()->projectDirectory(); const QString deployCommand = QLatin1String("rsync"); ProcessParameters *pp = processParameters(); Utils::Environment env = bc ? bc->environment() : Utils::Environment::systemEnvironment(); //TODO HACK if(!device.isNull()) env.appendOrSet(QLatin1String(Constants::MER_SSH_DEVICE_NAME),device->displayName()); pp->setMacroExpander(bc ? bc->macroExpander() : Core::VariableManager::instance()->macroExpander()); pp->setEnvironment(env); pp->setWorkingDirectory(projectDirectory); pp->setCommand(deployCommand); pp->setArguments(arguments()); return AbstractProcessStep::init(); }
void AutoreconfStepConfigWidget::updateDetails() { AutotoolsBuildConfiguration *bc = m_autoreconfStep->autotoolsBuildConfiguration(); ProcessParameters param; param.setMacroExpander(bc->macroExpander()); param.setEnvironment(bc->environment()); param.setWorkingDirectory(bc->buildDirectory()); param.setCommand("autoreconf"); param.setArguments(m_autoreconfStep->additionalArguments()); m_summaryText = param.summary(displayName()); emit updateSummary(); }
void ConfigureStepConfigWidget::updateDetails() { BuildConfiguration *bc = m_configureStep->buildConfiguration(); ProcessParameters param; param.setMacroExpander(bc->macroExpander()); param.setEnvironment(bc->environment()); param.setWorkingDirectory(bc->buildDirectory().toString()); param.setCommand(projectDirRelativeToBuildDir(bc) + QLatin1String("configure")); param.setArguments(m_configureStep->additionalArguments()); m_summaryText = param.summaryInWorkdir(displayName()); emit updateSummary(); }
bool AutogenStep::init() { BuildConfiguration *bc = buildConfiguration(); ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); pp->setEnvironment(bc->environment()); pp->setWorkingDirectory(bc->buildDirectory()); pp->setCommand(QLatin1String("autogen.sh")); pp->setArguments(additionalArguments()); return AbstractProcessStep::init(); }
bool ProcessStep::init() { BuildConfiguration *bc = buildConfiguration(); ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); pp->setEnvironment(bc->environment()); pp->setWorkingDirectory(workingDirectory()); pp->setCommand(m_command); pp->setArguments(m_arguments); AbstractProcessStep::setEnabled(m_enabled); setOutputParser(bc->createOutputParser()); return AbstractProcessStep::init(); }
void MakeStepConfigWidget::updateDetails() { ToolChain *tc = ToolChainKitInformation::toolChain(m_makeStep->target()->kit()); QmakeBuildConfiguration *bc = m_makeStep->qmakeBuildConfiguration(); if (!bc) bc = qobject_cast<QmakeBuildConfiguration *>(m_makeStep->target()->activeBuildConfiguration()); if (tc && bc) m_ui->makeLabel->setText(tr("Override %1:").arg(QDir::toNativeSeparators(tc->makeCommand(bc->environment())))); else m_ui->makeLabel->setText(tr("Make:")); if (!tc) { setSummaryText(tr("<b>Make:</b> %1").arg(ProjectExplorer::ToolChainKitInformation::msgNoToolChainInTarget())); return; } if (!bc) { setSummaryText(tr("<b>Make:</b> No Qt build configuration.")); return; } ProcessParameters param; param.setMacroExpander(bc->macroExpander()); param.setWorkingDirectory(bc->buildDirectory().toString()); QString makeCmd = tc->makeCommand(bc->environment()); if (!m_makeStep->makeCommand().isEmpty()) makeCmd = m_makeStep->makeCommand(); param.setCommand(makeCmd); QString args = m_makeStep->userArguments(); Utils::Environment env = bc->environment(); Utils::Environment::setupEnglishOutput(&env); // We prepend "L" to the MAKEFLAGS, so that nmake / jom are less verbose // FIXME doing this without the user having a way to override this is rather bad if (tc && m_makeStep->makeCommand().isEmpty()) { if (tc->targetAbi().os() == Abi::WindowsOS && tc->targetAbi().osFlavor() != Abi::WindowsMSysFlavor) { const QString makeFlags = QLatin1String("MAKEFLAGS"); env.set(makeFlags, QLatin1Char('L') + env.value(makeFlags)); } } param.setArguments(args); param.setEnvironment(env); if (param.commandMissing()) setSummaryText(tr("<b>Make:</b> %1 not found in the environment.").arg(makeCmd)); // Override display text else setSummaryText(param.summaryInWorkdir(displayName())); }
void AutogenStepConfigWidget::updateDetails() { BuildConfiguration *bc = m_autogenStep->buildConfiguration(); ProcessParameters param; param.setMacroExpander(bc->macroExpander()); param.setEnvironment(bc->environment()); const QString projectDir(bc->target()->project()->projectDirectory().toString()); param.setWorkingDirectory(projectDir); param.setCommand(QLatin1String("./autogen.sh")); param.setArguments(m_autogenStep->additionalArguments()); m_summaryText = param.summary(displayName()); emit updateSummary(); }
bool ConfigureStep::init(QList<const BuildStep *> &earlierSteps) { BuildConfiguration *bc = buildConfiguration(); ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); pp->setEnvironment(bc->environment()); pp->setWorkingDirectory(bc->buildDirectory().toString()); pp->setCommand(projectDirRelativeToBuildDir(bc) + QLatin1String("configure")); pp->setArguments(additionalArguments()); pp->resolveAll(); return AbstractProcessStep::init(earlierSteps); }
bool ProcessStep::init() { BuildConfiguration *bc = buildConfiguration(); ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc ? bc->macroExpander() : Utils::globalMacroExpander()); pp->setEnvironment(bc ? bc->environment() : Utils::Environment::systemEnvironment()); pp->setWorkingDirectory(workingDirectory()); pp->setCommand(m_command); pp->setArguments(m_arguments); pp->resolveAll(); setOutputParser(target()->kit()->createOutputParser()); return AbstractProcessStep::init(); }
void GenericMakeStepConfigWidget::updateDetails() { BuildConfiguration *bc = m_makeStep->buildConfiguration(); if (!bc) bc = m_makeStep->target()->activeBuildConfiguration(); ProcessParameters param; param.setMacroExpander(bc->macroExpander()); param.setWorkingDirectory(bc->buildDirectory().toString()); param.setEnvironment(bc->environment()); param.setCommand(m_makeStep->makeCommand(bc->environment())); param.setArguments(m_makeStep->allArguments()); m_summaryText = param.summary(displayName()); emit updateSummary(); }
bool AutogenStep::init() { BuildConfiguration *bc = buildConfiguration(); ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); pp->setEnvironment(bc->environment()); const QString projectDir(bc->target()->project()->projectDirectory().toString()); pp->setWorkingDirectory(projectDir); pp->setCommand(QLatin1String("./autogen.sh")); pp->setArguments(additionalArguments()); pp->resolveAll(); return AbstractProcessStep::init(); }
bool AutoreconfStep::init() { AutotoolsBuildConfiguration *bc = autotoolsBuildConfiguration(); setEnabled(true); ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); pp->setEnvironment(bc->environment()); pp->setWorkingDirectory(bc->buildDirectory()); pp->setCommand("autoreconf"); pp->setArguments(additionalArguments()); return AbstractProcessStep::init(); }
void IosPresetBuildStepConfigWidget::updateDetails() { BuildConfiguration *bc = m_buildStep->buildConfiguration(); if (!bc) bc = m_buildStep->target()->activeBuildConfiguration(); ProcessParameters param; param.setMacroExpander(bc->macroExpander()); param.setWorkingDirectory(bc->buildDirectory().toString()); param.setEnvironment(bc->environment()); param.setCommand(m_buildStep->command()); param.setArguments(Utils::QtcProcess::joinArgs(m_buildStep->arguments())); m_summaryText = param.summary(displayName()); emit updateSummary(); }
void ProcessStepConfigWidget::updateDetails() { QString displayName = m_step->displayName(); if (displayName.isEmpty()) displayName = tr("Custom Process Step"); ProcessParameters param; BuildConfiguration *bc = m_step->buildConfiguration(); param.setMacroExpander(bc ? bc->macroExpander() : Utils::globalMacroExpander()); param.setEnvironment(bc ? bc->environment() : Utils::Environment::systemEnvironment()); param.setWorkingDirectory(m_step->workingDirectory()); param.setCommand(m_step->command()); param.setArguments(m_step->arguments()); m_summaryText = param.summary(displayName); emit updateSummary(); }
bool MakeStep::init() { CMakeBuildConfiguration *bc = cmakeBuildConfiguration(); if (!bc) bc = targetsActiveBuildConfiguration(); if (!bc) emit addTask(Task::buildConfigurationMissingTask()); ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit()); if (!tc) emit addTask(Task::compilerMissingTask()); if (!bc || !tc) { emitFaultyConfigurationMessage(); return false; } m_useNinja = bc->useNinja(); QString arguments = Utils::QtcProcess::joinArgs(m_buildTargets); Utils::QtcProcess::addArgs(&arguments, additionalArguments()); setIgnoreReturnValue(m_clean); ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); Utils::Environment env = bc->environment(); // Force output to english for the parsers. Do this here and not in the toolchain's // addToEnvironment() to not screw up the users run environment. env.set(QLatin1String("LC_ALL"), QLatin1String("C")); if (m_useNinja && !env.value(QLatin1String("NINJA_STATUS")).startsWith(m_ninjaProgressString)) env.set(QLatin1String("NINJA_STATUS"), m_ninjaProgressString + QLatin1String("%o/sec] ")); pp->setEnvironment(env); pp->setWorkingDirectory(bc->buildDirectory().toString()); pp->setCommand(makeCommand(tc, bc->environment())); pp->setArguments(arguments); pp->resolveAll(); setOutputParser(new CMakeParser()); IOutputParser *parser = target()->kit()->createOutputParser(); if (parser) appendOutputParser(parser); outputParser()->setWorkingDirectory(pp->effectiveWorkingDirectory()); return AbstractProcessStep::init(); }
void ProcessStepConfigWidget::updateDetails() { QString displayName = m_step->displayName(); if (displayName.isEmpty()) displayName = tr("Custom Process Step"); ProcessParameters param; param.setMacroExpander(m_step->buildConfiguration()->macroExpander()); param.setEnvironment(m_step->buildConfiguration()->environment()); param.setWorkingDirectory(m_step->workingDirectory()); param.setCommand(m_step->command()); param.setArguments(m_step->arguments()); m_summaryText = param.summary(displayName); if (!m_step->enabled()) { //: %1 is the custom process step summary m_summaryText = tr("%1 (disabled)").arg(m_summaryText); } emit updateSummary(); }
void ProcessStepConfigWidget::updateDetails() { QString displayName = m_step->displayName(); if (displayName.isEmpty()) displayName = tr("Custom Process Step"); ProcessParameters param; BuildConfiguration *bc = m_step->buildConfiguration(); if (!bc) // iff the step is actually in the deploy list bc = m_step->target()->activeBuildConfiguration(); param.setMacroExpander(bc ? bc->macroExpander() : Core::VariableManager::macroExpander()); param.setEnvironment(bc ? bc->environment() : Utils::Environment::systemEnvironment()); param.setWorkingDirectory(m_step->workingDirectory()); param.setCommand(m_step->command()); param.setArguments(m_step->arguments()); m_summaryText = param.summary(displayName); emit updateSummary(); }
bool MakeStep::init(QList<const BuildStep *> &earlierSteps) { BuildConfiguration *bc = buildConfiguration(); if (!bc) bc = target()->activeBuildConfiguration(); if (!bc) emit addTask(Task::buildConfigurationMissingTask()); ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit()); if (!tc) emit addTask(Task::compilerMissingTask()); if (!tc || !bc) { emitFaultyConfigurationMessage(); return false; } QString arguments = Utils::QtcProcess::joinArgs(m_buildTargets); Utils::QtcProcess::addArgs(&arguments, additionalArguments()); setIgnoreReturnValue(m_clean); ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); Utils::Environment env = bc->environment(); // Force output to english for the parsers. Do this here and not in the toolchain's // addToEnvironment() to not screw up the users run environment. env.set(QLatin1String("LC_ALL"), QLatin1String("C")); pp->setEnvironment(env); pp->setWorkingDirectory(bc->buildDirectory().toString()); pp->setCommand(tc ? tc->makeCommand(bc->environment()) : QLatin1String("make")); pp->setArguments(arguments); pp->resolveAll(); setOutputParser(new GnuMakeParser()); IOutputParser *parser = target()->kit()->createOutputParser(); if (parser) appendOutputParser(parser); outputParser()->setWorkingDirectory(pp->effectiveWorkingDirectory()); return AbstractProcessStep::init(earlierSteps); }
bool IosBuildStep::init() { BuildConfiguration *bc = buildConfiguration(); if (!bc) bc = target()->activeBuildConfiguration(); if (!bc) emit addTask(Task::buildConfigurationMissingTask()); ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit()); if (!tc) emit addTask(Task::compilerMissingTask()); if (!bc || !tc) { emitFaultyConfigurationMessage(); return false; } ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); pp->setWorkingDirectory(bc->buildDirectory().toString()); Utils::Environment env = bc->environment(); // Force output to english for the parsers. Do this here and not in the toolchain's // addToEnvironment() to not screw up the users run environment. env.set(QLatin1String("LC_ALL"), QLatin1String("C")); pp->setEnvironment(env); pp->setCommand(buildCommand()); pp->setArguments(Utils::QtcProcess::joinArgs(allArguments())); pp->resolveAll(); // If we are cleaning, then build can fail with an error code, but that doesn't mean // we should stop the clean queue // That is mostly so that rebuild works on an already clean project setIgnoreReturnValue(m_clean); setOutputParser(new GnuMakeParser()); IOutputParser *parser = target()->kit()->createOutputParser(); if (parser) appendOutputParser(parser); outputParser()->setWorkingDirectory(pp->effectiveWorkingDirectory()); return AbstractProcessStep::init(); }
void MakeStepConfigWidget::updateDetails() { CMakeBuildConfiguration *bc = m_makeStep->cmakeBuildConfiguration(); ProjectExplorer::ToolChain *tc = bc->toolChain(); if (tc) { QString arguments = Utils::QtcProcess::joinArgs(m_makeStep->m_buildTargets); Utils::QtcProcess::addArgs(&arguments, m_makeStep->additionalArguments()); ProcessParameters param; param.setMacroExpander(bc->macroExpander()); param.setEnvironment(bc->environment()); param.setWorkingDirectory(bc->buildDirectory()); param.setCommand(tc->makeCommand()); param.setArguments(arguments); m_summaryText = param.summary(displayName()); } else { m_summaryText = tr("<b>Unknown tool chain</b>"); } emit updateSummary(); }
bool IosBuildStep::init() { BuildConfiguration *bc = buildConfiguration(); if (!bc) bc = target()->activeBuildConfiguration(); ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit()); if (!tc) { Task t = Task(Task::Error, tr("Qt Creator needs a compiler set up to build. Configure a compiler in the kit preferences."), Utils::FileName(), -1, Core::Id(ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM)); emit addTask(t); emit addOutput(tr("Configuration is faulty. Check the Issues output pane for details."), BuildStep::MessageOutput); return false; } ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); pp->setWorkingDirectory(bc->buildDirectory().toString()); Utils::Environment env = bc->environment(); // Force output to english for the parsers. Do this here and not in the toolchain's // addToEnvironment() to not screw up the users run environment. env.set(QLatin1String("LC_ALL"), QLatin1String("C")); pp->setEnvironment(env); pp->setCommand(buildCommand()); pp->setArguments(Utils::QtcProcess::joinArgs(allArguments())); pp->resolveAll(); // If we are cleaning, then build can fail with an error code, but that doesn't mean // we should stop the clean queue // That is mostly so that rebuild works on an already clean project setIgnoreReturnValue(m_clean); setOutputParser(new GnuMakeParser()); IOutputParser *parser = target()->kit()->createOutputParser(); if (parser) appendOutputParser(parser); outputParser()->setWorkingDirectory(pp->effectiveWorkingDirectory()); return AbstractProcessStep::init(); }
bool MakeStep::init() { AutotoolsBuildConfiguration *bc = autotoolsBuildConfiguration(); if (!bc) bc = static_cast<AutotoolsBuildConfiguration *>(target()->activeBuildConfiguration()); m_tasks.clear(); ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit()); if (!tc) { m_tasks.append(Task(Task::Error, tr("Qt Creator needs a compiler set up to build. Configure a compiler in the kit options."), Utils::FileName(), -1, Core::Id(ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM))); return true; // otherwise the tasks will not get reported } QString arguments = Utils::QtcProcess::joinArgs(m_buildTargets); Utils::QtcProcess::addArgs(&arguments, additionalArguments()); setIgnoreReturnValue(m_clean); ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); Utils::Environment env = bc->environment(); // Force output to english for the parsers. Do this here and not in the toolchain's // addToEnvironment() to not screw up the users run environment. env.set(QLatin1String("LC_ALL"), QLatin1String("C")); pp->setEnvironment(env); pp->setWorkingDirectory(bc->buildDirectory()); pp->setCommand(tc ? tc->makeCommand(bc->environment()) : QLatin1String("make")); pp->setArguments(arguments); setOutputParser(new GnuMakeParser()); QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(target()->kit()); if (version) appendOutputParser(new QtSupport::QtParser); if (tc) appendOutputParser(tc->outputParser()); outputParser()->setWorkingDirectory(pp->effectiveWorkingDirectory()); return AbstractProcessStep::init(); }
void MakeStepConfigWidget::updateDetails() { BuildConfiguration *bc = m_makeStep->buildConfiguration(); if (!bc) bc = m_makeStep->target()->activeBuildConfiguration(); ToolChain *tc = ToolChainKitInformation::toolChain(m_makeStep->target()->kit()); if (tc) { QString arguments = Utils::QtcProcess::joinArgs(m_makeStep->m_buildTargets); Utils::QtcProcess::addArgs(&arguments, m_makeStep->additionalArguments()); ProcessParameters param; param.setMacroExpander(bc->macroExpander()); param.setEnvironment(bc->environment()); param.setWorkingDirectory(bc->buildDirectory().toString()); param.setCommand(tc->makeCommand(bc->environment())); param.setArguments(arguments); m_summaryText = param.summary(displayName()); } else { m_summaryText = QLatin1String("<b>") + ProjectExplorer::ToolChainKitInformation::msgNoToolChainInTarget() + QLatin1String("</b>"); } emit updateSummary(); }
bool QMakeStep::init(QList<const BuildStep *> &earlierSteps) { if (m_commandFuture) return false; QmakeBuildConfiguration *qmakeBc = qmakeBuildConfiguration(); const BaseQtVersion *qtVersion = QtKitInformation::qtVersion(target()->kit()); if (!qtVersion) return false; QString workingDirectory; if (qmakeBc->subNodeBuild()) workingDirectory = qmakeBc->subNodeBuild()->buildDir(); else workingDirectory = qmakeBc->buildDirectory().toString(); m_qmakeExecutable = qtVersion->qmakeCommand().toString(); m_qmakeArguments = allArguments(qtVersion); m_runMakeQmake = (qtVersion->qtVersion() >= QtVersionNumber(5, 0 ,0)); if (m_runMakeQmake) { m_makeExecutable = makeCommand(); if (m_makeExecutable.isEmpty()) return false; } else { m_makeExecutable.clear(); } QString makefile = workingDirectory; if (qmakeBc->subNodeBuild()) { if (!qmakeBc->subNodeBuild()->makefile().isEmpty()) makefile.append(qmakeBc->subNodeBuild()->makefile()); else makefile.append(QLatin1String("/Makefile")); } else if (!qmakeBc->makefile().isEmpty()) { makefile.append(QLatin1Char('/')); makefile.append(qmakeBc->makefile()); } else { makefile.append(QLatin1String("/Makefile")); } // Check whether we need to run qmake bool makefileOutDated = (qmakeBc->compareToImportFrom(makefile) != QmakeBuildConfiguration::MakefileMatches); if (m_forced || makefileOutDated) m_needToRunQMake = true; m_forced = false; ProcessParameters *pp = processParameters(); pp->setMacroExpander(qmakeBc->macroExpander()); pp->setWorkingDirectory(workingDirectory); pp->setEnvironment(qmakeBc->environment()); setOutputParser(new QMakeParser); QmakeProFileNode *node = static_cast<QmakeProject *>(qmakeBc->target()->project())->rootProjectNode(); if (qmakeBc->subNodeBuild()) node = qmakeBc->subNodeBuild(); QString proFile = node->filePath().toString(); QList<ProjectExplorer::Task> tasks = qtVersion->reportIssues(proFile, workingDirectory); Utils::sort(tasks); if (!tasks.isEmpty()) { bool canContinue = true; foreach (const ProjectExplorer::Task &t, tasks) { addTask(t); if (t.type == Task::Error) canContinue = false; }
bool MakeStep::init(QList<const BuildStep *> &earlierSteps) { QmakeBuildConfiguration *bc = qmakeBuildConfiguration(); if (!bc) bc = qobject_cast<QmakeBuildConfiguration *>(target()->activeBuildConfiguration()); if (!bc) emit addTask(Task::buildConfigurationMissingTask()); ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit()); if (!tc) emit addTask(Task::compilerMissingTask()); if (!bc || !tc) { emitFaultyConfigurationMessage(); return false; } ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); QString workingDirectory; if (bc->subNodeBuild()) workingDirectory = bc->subNodeBuild()->buildDir(); else workingDirectory = bc->buildDirectory().toString(); pp->setWorkingDirectory(workingDirectory); pp->setCommand(effectiveMakeCommand()); // If we are cleaning, then make can fail with a error code, but that doesn't mean // we should stop the clean queue // That is mostly so that rebuild works on a already clean project setIgnoreReturnValue(m_clean); QString args; QmakeProjectManager::QmakeProFileNode *subNode = bc->subNodeBuild(); if (subNode) { QString makefile = subNode->makefile(); if (makefile.isEmpty()) makefile = QLatin1String("Makefile"); // Use Makefile.Debug and Makefile.Release // for file builds, since the rules for that are // only in those files. if (subNode->isDebugAndRelease() && bc->fileNodeBuild()) { if (bc->buildType() == QmakeBuildConfiguration::Debug) makefile += QLatin1String(".Debug"); else makefile += QLatin1String(".Release"); } if (makefile != QLatin1String("Makefile")) { Utils::QtcProcess::addArg(&args, QLatin1String("-f")); Utils::QtcProcess::addArg(&args, makefile); } m_makeFileToCheck = QDir(workingDirectory).filePath(makefile); } else { if (!bc->makefile().isEmpty()) { Utils::QtcProcess::addArg(&args, QLatin1String("-f")); Utils::QtcProcess::addArg(&args, bc->makefile()); m_makeFileToCheck = QDir(workingDirectory).filePath(bc->makefile()); } else { m_makeFileToCheck = QDir(workingDirectory).filePath(QLatin1String("Makefile")); } } Utils::QtcProcess::addArgs(&args, m_userArgs); if (bc->fileNodeBuild() && subNode) { QString objectsDir = subNode->objectsDirectory(); if (objectsDir.isEmpty()) { objectsDir = subNode->buildDir(bc); if (subNode->isDebugAndRelease()) { if (bc->buildType() == QmakeBuildConfiguration::Debug) objectsDir += QLatin1String("/debug"); else objectsDir += QLatin1String("/release"); } } QString relObjectsDir = QDir(pp->workingDirectory()).relativeFilePath(objectsDir); if (relObjectsDir == QLatin1String(".")) relObjectsDir.clear(); if (!relObjectsDir.isEmpty()) relObjectsDir += QLatin1Char('/'); QString objectFile = relObjectsDir + bc->fileNodeBuild()->filePath().toFileInfo().baseName() + subNode->objectExtension(); Utils::QtcProcess::addArg(&args, objectFile); } Utils::Environment env = bc->environment(); Utils::Environment::setupEnglishOutput(&env); // We also prepend "L" to the MAKEFLAGS, so that nmake / jom are less verbose if (tc && makeCommand().isEmpty()) { if (tc->targetAbi().os() == Abi::WindowsOS && tc->targetAbi().osFlavor() != Abi::WindowsMSysFlavor) { const QString makeFlags = QLatin1String("MAKEFLAGS"); env.set(makeFlags, QLatin1Char('L') + env.value(makeFlags)); } } pp->setEnvironment(env); pp->setArguments(args); pp->resolveAll(); setOutputParser(new ProjectExplorer::GnuMakeParser()); if (tc && tc->targetAbi().os() == Abi::MacOS) appendOutputParser(new XcodebuildParser); IOutputParser *parser = target()->kit()->createOutputParser(); if (parser) appendOutputParser(parser); outputParser()->setWorkingDirectory(pp->effectiveWorkingDirectory()); appendOutputParser(new QMakeParser); // make may cause qmake to be run, add last to make sure // it has a low priority. m_scriptTarget = (static_cast<QmakeProject *>(bc->target()->project())->rootProjectNode()->projectType() == ScriptTemplate); return AbstractProcessStep::init(earlierSteps); }
bool QMakeStep::init() { Qt4BuildConfiguration *qt4bc = qt4BuildConfiguration(); const QtSupport::BaseQtVersion *qtVersion = qt4bc->qtVersion(); if (!qtVersion) return false; QString args = allArguments(); QString workingDirectory; if (qt4bc->subNodeBuild()) workingDirectory = qt4bc->subNodeBuild()->buildDir(); else workingDirectory = qt4bc->buildDirectory(); QString program = qtVersion->qmakeCommand(); // Check whether we need to run qmake m_needToRunQMake = true; QString makefile = workingDirectory; if (qt4bc->subNodeBuild()) { if (!qt4bc->subNodeBuild()->makefile().isEmpty()) { makefile.append(qt4bc->subNodeBuild()->makefile()); } else { makefile.append("/Makefile"); } } else if (!qt4bc->makefile().isEmpty()) { makefile.append("/"); makefile.append(qt4bc->makefile()); } else { makefile.append("/Makefile"); } if (QFileInfo(makefile).exists()) { QString qmakePath = QtSupport::QtVersionManager::findQMakeBinaryFromMakefile(makefile); if (qtVersion->qmakeCommand() == qmakePath) { m_needToRunQMake = !qt4bc->compareToImportFrom(makefile); } } if (m_forced) { m_forced = false; m_needToRunQMake = true; } setEnabled(m_needToRunQMake); ProcessParameters *pp = processParameters(); pp->setMacroExpander(qt4bc->macroExpander()); pp->setWorkingDirectory(workingDirectory); pp->setCommand(program); pp->setArguments(args); pp->setEnvironment(qt4bc->environment()); setOutputParser(new QMakeParser); Qt4ProFileNode *node = qt4bc->qt4Target()->qt4Project()->rootProjectNode(); if (qt4bc->subNodeBuild()) node = qt4bc->subNodeBuild(); QString proFile = node->path(); QtSupport::BaseQtVersion *version = qt4BuildConfiguration()->qtVersion(); m_tasks = version->reportIssues(proFile, workingDirectory); foreach (Qt4BaseTargetFactory *factory, Qt4BaseTargetFactory::qt4BaseTargetFactoriesForIds(version->supportedTargetIds().toList())) m_tasks.append(factory->reportIssues(proFile)); qSort(m_tasks); m_scriptTemplate = node->projectType() == ScriptTemplate; return AbstractProcessStep::init(); }