void AbstractProcessStep::run(QFutureInterface<bool> &fi)
{
m_futureInterface = &fi;
QDir wd(m_param.effectiveWorkingDirectory());
if (!wd.exists()) {
if (!wd.mkpath(wd.absolutePath())) {
emit addOutput(tr("Could not create directory \"%1\"")
.arg(QDir::toNativeSeparators(wd.absolutePath())),
BuildStep::ErrorMessageOutput);
fi.reportResult(false);
emit finished();
return;
}
}
QString effectiveCommand = m_param.effectiveCommand();
if (!QFileInfo::exists(effectiveCommand)) {
processStartupFailed();
fi.reportResult(false);
emit finished();
return;
}
m_process = new Utils::QtcProcess();
if (Utils::HostOsInfo::isWindowsHost())
m_process->setUseCtrlCStub(true);
m_process->setWorkingDirectory(wd.absolutePath());
m_process->setEnvironment(m_param.environment());
connect(m_process, SIGNAL(readyReadStandardOutput()),
this, SLOT(processReadyReadStdOutput()));
connect(m_process, SIGNAL(readyReadStandardError()),
this, SLOT(processReadyReadStdError()));
connect(m_process, SIGNAL(finished(int,QProcess::ExitStatus)),
this, SLOT(slotProcessFinished(int,QProcess::ExitStatus)));
m_process->setCommand(effectiveCommand, m_param.effectiveArguments());
m_process->start();
if (!m_process->waitForStarted()) {
processStartupFailed();
delete m_process;
m_process = 0;
fi.reportResult(false);
emit finished();
return;
}
processStarted();
m_timer = new QTimer();
connect(m_timer, SIGNAL(timeout()), this, SLOT(checkForCancel()));
m_timer->start(500);
m_killProcess = false;
}
void QMakeStep::run(QFutureInterface<bool> &fi)
{
if (qobject_cast<Qt4Project *>(project())->rootProjectNode()->projectType() == ScriptTemplate) {
fi.reportResult(true);
return;
}
if (!enabled(m_buildConfiguration)) {
emit addToOutputWindow(tr("<font color=\"#0000ff\">Configuration unchanged, skipping QMake step.</font>"));
fi.reportResult(true);
return;
}
AbstractProcessStep::run(fi);
}
void MakeStep::run(QFutureInterface<bool> & fi)
{
if (qobject_cast<Qt4Project *>(project())->rootProjectNode()->projectType() == ScriptTemplate) {
fi.reportResult(true);
return;
}
if (!enabled(m_buildConfiguration)) {
emit addToOutputWindow(tr("<font color=\"#0000ff\"><b>No Makefile found, assuming project is clean.</b></font>"));
fi.reportResult(true);
return;
}
AbstractMakeStep::run(fi);
}
void AutogenStep::run(QFutureInterface<bool> &interface)
{
BuildConfiguration *bc = buildConfiguration();
// Check whether we need to run autogen.sh
const QString projectDir(bc->target()->project()->projectDirectory().toString());
const QFileInfo configureInfo(projectDir + QLatin1String("/configure"));
const QFileInfo configureAcInfo(projectDir + QLatin1String("/configure.ac"));
const QFileInfo makefileAmInfo(projectDir + QLatin1String("/Makefile.am"));
if (!configureInfo.exists()
|| configureInfo.lastModified() < configureAcInfo.lastModified()
|| configureInfo.lastModified() < makefileAmInfo.lastModified()) {
m_runAutogen = true;
}
if (!m_runAutogen) {
emit addOutput(tr("Configuration unchanged, skipping autogen step."), BuildStep::MessageOutput);
interface.reportResult(true);
emit finished();
return;
}
m_runAutogen = false;
AbstractProcessStep::run(interface);
}
void AndroidDeployQtStep::run(QFutureInterface<bool> &fi)
{
if (!m_avdName.isEmpty()) {
QString serialNumber = AndroidConfigurations::instance().waitForAvd(m_deviceAPILevel, m_targetArch);
if (serialNumber.isEmpty()) {
fi.reportResult(false);
return;
}
m_serialNumber = serialNumber;
QString args = processParameters()->arguments();
Utils::QtcProcess::addArg(&args, QLatin1String("--device"));
Utils::QtcProcess::addArg(&args, serialNumber);
processParameters()->setArguments(args);
}
AbstractProcessStep::run(fi);
emit addOutput(tr("Pulling files necessary for debugging."), MessageOutput);
runCommand(AndroidConfigurations::instance().adbToolPath().toString(),
AndroidDeviceInfo::adbSelector(m_serialNumber)
<< QLatin1String("pull") << QLatin1String("/system/bin/app_process")
<< QString::fromLatin1("%1/app_process").arg(m_buildDirectory));
runCommand(AndroidConfigurations::instance().adbToolPath().toString(),
AndroidDeviceInfo::adbSelector(m_serialNumber) << QLatin1String("pull")
<< QLatin1String("/system/lib/libc.so")
<< QString::fromLatin1("%1/libc.so").arg(m_buildDirectory));
}
static void createProposal(QFutureInterface<QStringList> &future, const QString &text,
const QString &wordUnderCursor)
{
const QRegularExpression wordRE("([a-zA-Z_][a-zA-Z0-9_]{2,})");
QSet<QString> words;
QRegularExpressionMatchIterator it = wordRE.globalMatch(text);
int wordUnderCursorFound = 0;
while (it.hasNext()) {
if (future.isCanceled())
return;
QRegularExpressionMatch match = it.next();
const QString &word = match.captured();
if (word == wordUnderCursor) {
// Only add the word under cursor if it
// already appears elsewhere in the text
if (++wordUnderCursorFound < 2)
continue;
}
if (!words.contains(word))
words.insert(word);
}
future.reportResult(words.toList());
}
void BlackBerryAbstractDeployStep::run(QFutureInterface<bool> &fi)
{
m_timer = new QTimer();
connect(m_timer, SIGNAL(timeout()), this, SLOT(checkForCancel()), Qt::DirectConnection);
m_timer->start(500);
m_eventLoop = new QEventLoop;
fi.setProgressRange(0, 100 * m_params.size());
Q_ASSERT(!m_futureInterface);
m_futureInterface = &fi;
runCommands();
bool returnValue = m_eventLoop->exec();
// Finished
m_params.clear();
m_processCounter = -1;
m_timer->stop();
delete m_timer;
m_timer = 0;
delete m_process;
m_process = 0;
delete m_eventLoop;
m_eventLoop = 0;
m_futureInterface = 0;
fi.reportResult(returnValue);
}
static void findProcessPID(QFutureInterface<qint64> &fi, QStringList selector,
const QString &packageName, bool preNougat)
{
qCDebug(androidRunWorkerLog) << "Finding PID. PreNougat:" << preNougat;
if (packageName.isEmpty())
return;
qint64 processPID = -1;
chrono::high_resolution_clock::time_point start = chrono::high_resolution_clock::now();
selector.append("shell");
selector.append(preNougat ? pidScriptPreNougat : pidScript.arg(packageName));
do {
QThread::msleep(200);
SdkToolResult result = AndroidManager::runAdbCommand(selector);
if (preNougat) {
processPID = extractPID(result.stdOut(), packageName);
} else {
if (!result.stdOut().isEmpty())
processPID = result.stdOut().trimmed().toLongLong();
}
} while (processPID == -1 && !isTimedOut(start) && !fi.isCanceled());
qCDebug(androidRunWorkerLog) << "PID found:" << processPID;
if (!fi.isCanceled())
fi.reportResult(processPID);
}
void MakeStep::run(QFutureInterface<bool> & fi)
{
if (qt4BuildConfiguration()->qt4Target()->qt4Project()->rootProjectNode()->projectType() == ScriptTemplate) {
fi.reportResult(true);
return;
}
AbstractProcessStep::run(fi);
}
void AndroidDeployQtStep::run(QFutureInterface<bool> &fi)
{
if (!m_avdName.isEmpty()) {
QString serialNumber = AndroidConfigurations::currentConfig().waitForAvd(m_deviceAPILevel, m_targetArch, fi);
if (serialNumber.isEmpty()) {
fi.reportResult(false);
emit finished();
return;
}
m_serialNumber = serialNumber;
emit setSerialNumber(serialNumber);
}
DeployResult returnValue = runDeploy(fi);
if (returnValue == AskUinstall) {
emit askForUninstall();
if (m_askForUinstall) {
m_uninstallPreviousPackageRun = true;
returnValue = runDeploy(fi);
}
}
emit addOutput(tr("Pulling files necessary for debugging."), MessageOutput);
QString localAppProcessFile = QString::fromLatin1("%1/app_process").arg(m_buildDirectory);
runCommand(m_adbPath,
AndroidDeviceInfo::adbSelector(m_serialNumber)
<< QLatin1String("pull") << QLatin1String("/system/bin/app_process")
<< localAppProcessFile);
// Workaround for QTCREATORBUG-14201: /system/bin/app_process might be a link to asan/app_process
if (!QFileInfo::exists(localAppProcessFile)) {
runCommand(m_adbPath,
AndroidDeviceInfo::adbSelector(m_serialNumber)
<< QLatin1String("pull") << QLatin1String("/system/bin/asan/app_process")
<< localAppProcessFile);
}
runCommand(m_adbPath,
AndroidDeviceInfo::adbSelector(m_serialNumber) << QLatin1String("pull")
<< QLatin1String("/system/lib/libc.so")
<< QString::fromLatin1("%1/libc.so").arg(m_buildDirectory));
fi.reportResult(returnValue == Success ? true : false);
fi.reportFinished();
}
void MerEmulatorStartStep::run(QFutureInterface<bool> &fi)
{
MerConnectionManager *em = MerConnectionManager::instance();
if(em->isConnected(m_vm)) {
emit addOutput(tr("Emulator is already running. Nothing to do."),MessageOutput);
fi.reportResult(true);
emit finished();
} else {
emit addOutput(tr("Starting Emulator..."), MessageOutput);
QString error = tr("Could not connect to %1 Virtual Machine.").arg(m_vm);
MerConnection::createConnectionErrorTask(m_vm,error,Constants::MER_TASKHUB_EMULATOR_CATEGORY);
if(!MerVirtualBoxManager::isVirtualMachineRunning(m_vm)) {
MerConnectionPrompt *connectioPrompt = new MerConnectionPrompt(m_vm, 0);
connectioPrompt->prompt(MerConnectionPrompt::Start);
}
fi.reportResult(false);
emit finished();
}
}
void QmakeAndroidBuildApkStep::run(QFutureInterface<bool> &fi)
{
if (m_skipBuilding) {
emit addOutput(tr("No application .pro file found, not building an APK."), BuildStep::ErrorMessageOutput);
fi.reportResult(true);
emit finished();
return;
}
AndroidBuildApkStep::run(fi);
}
void TarPackageCreationStep::run(QFutureInterface<bool> &fi)
{
setPackagingStarted();
const bool success = doPackage(fi);
setPackagingFinished(success);
if (success)
emit addOutput(tr("Packaging finished successfully."), MessageOutput);
else
emit addOutput(tr("Packaging failed."), ErrorMessageOutput);
fi.reportResult(success);
}
void MakeStep::run(QFutureInterface<bool> & fi)
{
if (qt4BuildConfiguration()->qt4Target()->qt4Project()->rootProjectNode()->projectType() == ScriptTemplate) {
fi.reportResult(true);
return;
}
if (!QFileInfo(m_makeFileToCheck).exists()) {
if (!m_clean)
emit addOutput(tr("Makefile not found. Please check your build settings"), BuildStep::MessageOutput);
fi.reportResult(m_clean);
return;
}
// Warn on common error conditions:
bool canContinue = true;
foreach (const ProjectExplorer::Task &t, m_tasks) {
addTask(t);
if (t.type == ProjectExplorer::Task::Error)
canContinue = false;
}
void MakeStep::run(QFutureInterface<bool> & fi)
{
if (m_scriptTarget) {
fi.reportResult(true);
return;
}
if (!QFileInfo(m_makeFileToCheck).exists()) {
if (!ignoreReturnValue())
emit addOutput(tr("Cannot find Makefile. Check your build settings."), BuildStep::MessageOutput);
fi.reportResult(ignoreReturnValue());
return;
}
// Warn on common error conditions:
bool canContinue = true;
foreach (const ProjectExplorer::Task &t, m_tasks) {
addTask(t);
if (t.type == ProjectExplorer::Task::Error)
canContinue = false;
}
void AndroidDeployQtStep::run(QFutureInterface<bool> &fi)
{
m_installOk = true;
if (!m_avdName.isEmpty()) {
QString serialNumber = AndroidConfigurations::currentConfig().waitForAvd(m_deviceAPILevel, m_targetArch, fi);
if (serialNumber.isEmpty()) {
fi.reportResult(false);
emit finished();
return;
}
m_serialNumber = serialNumber;
AndroidManager::setDeviceSerialNumber(target(), serialNumber);
}
ProjectExplorer::ProcessParameters *pp = processParameters();
if (m_useAndroiddeployqt) {
if (!m_serialNumber.isEmpty() && !m_serialNumber.startsWith(QLatin1String("????"))) {
Utils::QtcProcess::addArg(&m_androiddeployqtArgs, QLatin1String("--device"));
Utils::QtcProcess::addArg(&m_androiddeployqtArgs, m_serialNumber);
}
pp->setArguments(m_androiddeployqtArgs);
} else {
if (m_uninstallPreviousPackageRun) {
emit addOutput(tr("Uninstall previous package %1.").arg(m_packageName), MessageOutput);
runCommand(AndroidConfigurations::currentConfig().adbToolPath().toString(),
AndroidDeviceInfo::adbSelector(m_serialNumber)
<< QLatin1String("uninstall") << m_packageName);
}
QString args;
foreach (const QString &arg, AndroidDeviceInfo::adbSelector(m_serialNumber))
Utils::QtcProcess::addArg(&args, arg);
Utils::QtcProcess::addArg(&args, QLatin1String("install"));
Utils::QtcProcess::addArg(&args, QLatin1String("-r"));
Utils::QtcProcess::addArg(&args, m_apkPath);
pp->setArguments(args);
}
pp->resolveAll();
AbstractProcessStep::run(fi);
emit addOutput(tr("Pulling files necessary for debugging."), MessageOutput);
runCommand(AndroidConfigurations::currentConfig().adbToolPath().toString(),
AndroidDeviceInfo::adbSelector(m_serialNumber)
<< QLatin1String("pull") << QLatin1String("/system/bin/app_process")
<< QString::fromLatin1("%1/app_process").arg(m_buildDirectory));
runCommand(AndroidConfigurations::currentConfig().adbToolPath().toString(),
AndroidDeviceInfo::adbSelector(m_serialNumber) << QLatin1String("pull")
<< QLatin1String("/system/lib/libc.so")
<< QString::fromLatin1("%1/libc.so").arg(m_buildDirectory));
}
void QMakeStep::run(QFutureInterface<bool> &fi)
{
if (m_scriptTemplate) {
fi.reportResult(true);
return;
}
// Warn on common error conditions:
bool canContinue = true;
foreach (const ProjectExplorer::Task &t, m_tasks) {
addTask(t);
if (t.type == Task::Error)
canContinue = false;
}
void AndroidPackageInstallationStep::run(QFutureInterface<bool> &fi)
{
QString error;
Utils::FileName androidDir = Utils::FileName::fromString(m_androidDirToClean);
if (!m_androidDirToClean.isEmpty()&& androidDir.toFileInfo().exists()) {
emit addOutput(tr("Removing directory %1").arg(m_androidDirToClean), MessageOutput);
if (!Utils::FileUtils::removeRecursively(androidDir, &error)) {
emit addOutput(error, ErrorOutput);
fi.reportResult(false);
emit finished();
return;
}
}
AbstractProcessStep::run(fi);
}
static void performTestRun(QFutureInterface<TestResult *> &futureInterface,
const QList<TestConfiguration *> selectedTests, const int timeout,
const QString metricsOption)
{
QEventLoop eventLoop;
int testCaseCount = 0;
foreach (TestConfiguration *config, selectedTests) {
config->completeTestInformation();
if (config->project()) {
testCaseCount += config->testCaseCount();
} else {
futureInterface.reportResult(new FaultyTestResult(Result::MessageWarn,
QObject::tr("Project is null for \"%1\". Removing from test run.\n"
"Check the test environment.").arg(config->displayName())));
}
}
void MerUploadAndInstallRpmStep::run(QFutureInterface<bool> &fi)
{
const QString packageFile = m_packagingStep->packagesFilePath().first();
if(!packageFile.endsWith(QLatin1String(".rpm"))){
const QString message((tr("No package to deploy found in %1")).arg(packageFile));
emit addOutput(message, ErrorMessageOutput);
emit addTask(Task(Task::Error, message, FileName(), -1,
Core::Id(Constants::TASK_CATEGORY_BUILDSYSTEM)));
fi.reportResult(false);
emit finished();
return;
}
m_deployService->setPackageFilePath(packageFile);
AbstractRemoteLinuxDeployStep::run(fi);
}
void ManagerProcessor::process(QFutureInterface<Manager::RegisterData> &future)
{
future.setProgressRange(0, kMaxProgress);
Manager::RegisterData data;
// iterate through paths in order, high priority > low priority
foreach (const QString &path, m_definitionsPaths) {
if (path.isEmpty())
continue;
QDir definitionsDir(path);
QStringList filter(QLatin1String("*.xml"));
definitionsDir.setNameFilters(filter);
foreach (const QFileInfo &fileInfo, definitionsDir.entryInfoList()) {
if (future.isCanceled())
return;
if (future.progressValue() < kMaxProgress - 1)
future.setProgressValue(future.progressValue() + 1);
const DefinitionMetaDataPtr &metaData =
Manager::parseMetadata(fileInfo);
// skip failing or already existing definitions
if (!metaData.isNull() && !data.m_idByName.contains(metaData->name)) {
const QString id = metaData->id;
data.m_idByName.insert(metaData->name, id);
data.m_definitionsMetaData.insert(id, metaData);
foreach (const QString &mt, metaData->mimeTypes) {
bool insert = true;
// check if there is already a definition registered with higher priority
const QString existingDefinition = data.m_idByMimeType.value(mt);
if (!existingDefinition.isEmpty()) {
// check priorities
DefinitionMetaDataPtr existingMetaData =
data.m_definitionsMetaData.value(existingDefinition);
if (!existingMetaData.isNull() && existingMetaData->priority > metaData->priority)
insert = false;
}
if (insert)
data.m_idByMimeType.insert(mt, id);
}
}
}
}
future.reportResult(data);
}
void Locator::Internal::runSearch(QFutureInterface<Locator::FilterEntry> &entries,
QList<ILocatorFilter *> filters, QString searchText)
{
QSet<FilterEntry> alreadyAdded;
const bool checkDuplicates = (filters.size() > 1);
foreach (ILocatorFilter *filter, filters) {
if (entries.isCanceled())
break;
foreach (const FilterEntry &entry, filter->matchesFor(entries, searchText)) {
if (checkDuplicates && alreadyAdded.contains(entry))
continue;
entries.reportResult(entry);
if (checkDuplicates)
alreadyAdded.insert(entry);
}
}
}
void QmlTaskManager::collectMessages(
QFutureInterface<FileErrorMessages> &future,
Snapshot snapshot, QList<ModelManagerInterface::ProjectInfo> projectInfos,
ViewerContext vContext, bool updateSemantic)
{
foreach (const ModelManagerInterface::ProjectInfo &info, projectInfos) {
QHash<QString, QList<DiagnosticMessage> > linkMessages;
ContextPtr context;
if (updateSemantic) {
Link link(snapshot, vContext, snapshot.libraryInfo(info.qtImportsPath));
context = link(&linkMessages);
}
foreach (const QString &fileName, info.sourceFiles) {
Document::Ptr document = snapshot.document(fileName);
if (!document)
continue;
FileErrorMessages result;
result.fileName = fileName;
if (Document::isFullySupportedLanguage(document->language())) {
result.tasks = convertToTasks(document->diagnosticMessages(),
Utils::FileName::fromString(fileName),
Core::Id(Constants::TASK_CATEGORY_QML));
if (updateSemantic) {
result.tasks += convertToTasks(linkMessages.value(fileName),
Utils::FileName::fromString(fileName),
Core::Id(Constants::TASK_CATEGORY_QML_ANALYSIS));
Check checker(document, context);
result.tasks += convertToTasks(checker(),
Utils::FileName::fromString(fileName),
Core::Id(Constants::TASK_CATEGORY_QML_ANALYSIS));
}
}
if (!result.tasks.isEmpty())
future.reportResult(result);
if (future.isCanceled())
break;
}
}
void findProcessPIDPreNougat(QFutureInterface<qint64> &fi, const QString &adbPath,
QStringList selector, const QString &packageName)
{
if (packageName.isEmpty())
return;
qint64 processPID = -1;
chrono::high_resolution_clock::time_point start = chrono::high_resolution_clock::now();
do {
QThread::msleep(200);
const QByteArray out = Utils::SynchronousProcess()
.runBlocking(adbPath, selector << QStringLiteral("shell") << pidScriptPreNougat)
.allRawOutput();
processPID = extractPID(out, packageName);
} while (processPID == -1 && !isTimedOut(start) && !fi.isCanceled());
if (!fi.isCanceled())
fi.reportResult(processPID);
}
void AutoreconfStep::run(QFutureInterface<bool> &interface)
{
AutotoolsBuildConfiguration *bc = autotoolsBuildConfiguration();
// Check whether we need to run autoreconf
const QFileInfo configureInfo(bc->buildDirectory() + QLatin1String("/configure"));
if (!configureInfo.exists())
m_runAutoreconf = true;
if (!m_runAutoreconf) {
emit addOutput(tr("Configuration unchanged, skipping autoreconf step."), BuildStep::MessageOutput);
interface.reportResult(true);
return;
}
m_runAutoreconf = false;
AbstractProcessStep::run(interface);
}
static bool checkQmlDocumentForQuickTestCode(QFutureInterface<TestParseResultPtr> futureInterface,
const QmlJS::Document::Ptr &qmlJSDoc,
const Core::Id &id,
const QString &proFile = QString())
{
if (qmlJSDoc.isNull())
return false;
QmlJS::AST::Node *ast = qmlJSDoc->ast();
QTC_ASSERT(ast, return false);
TestQmlVisitor qmlVisitor(qmlJSDoc);
QmlJS::AST::Node::accept(ast, &qmlVisitor);
const QString testCaseName = qmlVisitor.testCaseName();
const TestCodeLocationAndType tcLocationAndType = qmlVisitor.testCaseLocation();
const QMap<QString, TestCodeLocationAndType> &testFunctions = qmlVisitor.testFunctions();
QuickTestParseResult *parseResult = new QuickTestParseResult(id);
parseResult->proFile = proFile;
parseResult->itemType = TestTreeItem::TestCase;
QMap<QString, TestCodeLocationAndType>::ConstIterator it = testFunctions.begin();
const QMap<QString, TestCodeLocationAndType>::ConstIterator end = testFunctions.end();
for ( ; it != end; ++it) {
const TestCodeLocationAndType &loc = it.value();
QuickTestParseResult *funcResult = new QuickTestParseResult(id);
funcResult->name = it.key();
funcResult->displayName = it.key();
funcResult->itemType = loc.m_type;
funcResult->fileName = loc.m_name;
funcResult->line = loc.m_line;
funcResult->column = loc.m_column;
funcResult->proFile = proFile;
parseResult->children.append(funcResult);
}
if (!testCaseName.isEmpty()) {
parseResult->fileName = tcLocationAndType.m_name;
parseResult->name = testCaseName;
parseResult->line = tcLocationAndType.m_line;
parseResult->column = tcLocationAndType.m_column;
}
futureInterface.reportResult(TestParseResultPtr(parseResult));
return true;
}
QFuture<DeadLyRicS::LyricsQueryResult_t> DeadLyRicS::RequestLyrics (const Media::LyricsQuery& query)
{
if (query.Artist_.isEmpty () || query.Title_.isEmpty ())
return Util::MakeReadyFuture (LyricsQueryResult_t { tr ("Not enough parameters to build a search query.") });
QFutureInterface<LyricsQueryResult_t> promise;
promise.reportStarted ();
promise.setExpectedResultCount (Searchers_.size ());
for (auto searcher : Searchers_)
searcher->Search (query,
[promise] (const LyricsQueryResult_t& result) mutable
{
const auto currentCount = promise.resultCount ();
promise.reportResult (result, currentCount);
if (currentCount + 1 == promise.expectedResultCount ())
promise.reportFinished ();
});
return promise.future ();
}
void ConfigureStep::run(QFutureInterface<bool>& interface)
{
AutotoolsBuildConfiguration *bc = autotoolsBuildConfiguration();
//Check whether we need to run configure
const QFileInfo configureInfo(bc->buildDirectory() + QLatin1String("/configure"));
const QFileInfo configStatusInfo(bc->buildDirectory() + QLatin1String("/config.status"));
if (!configStatusInfo.exists()
|| configStatusInfo.lastModified() < configureInfo.lastModified()) {
m_runConfigure = true;
}
if (!m_runConfigure) {
emit addOutput(tr("Configuration unchanged, skipping configure step."), BuildStep::MessageOutput);
interface.reportResult(true);
return;
}
m_runConfigure = false;
AbstractProcessStep::run(interface);
}
void AbstractProcessStep::run(QFutureInterface<bool> &fi)
{
m_futureInterface = &fi;
QDir wd(m_param.effectiveWorkingDirectory());
if (!wd.exists())
wd.mkpath(wd.absolutePath());
m_process = new Utils::QtcProcess();
#ifdef Q_OS_WIN
m_process->setUseCtrlCStub(true);
#endif
m_process->setWorkingDirectory(wd.absolutePath());
m_process->setEnvironment(m_param.effectiveEnvironment());
connect(m_process, SIGNAL(readyReadStandardOutput()),
this, SLOT(processReadyReadStdOutput()));
connect(m_process, SIGNAL(readyReadStandardError()),
this, SLOT(processReadyReadStdError()));
connect(m_process, SIGNAL(finished(int,QProcess::ExitStatus)),
this, SLOT(slotProcessFinished(int,QProcess::ExitStatus)));
m_process->setCommand(m_param.effectiveCommand(), m_param.effectiveArguments());
m_process->start();
if (!m_process->waitForStarted()) {
processStartupFailed();
delete m_process;
m_process = 0;
fi.reportResult(false);
emit finished();
return;
}
processStarted();
m_timer = new QTimer();
connect(m_timer, SIGNAL(timeout()), this, SLOT(checkForCancel()));
m_timer->start(500);
m_killProcess = false;
}
void BuildStep::reportRunResult(QFutureInterface<bool> &fi, bool success)
{
fi.reportResult(success);
fi.reportFinished();
}
