static inline QString detectSsh()
{
const QByteArray gitSsh = qgetenv("GIT_SSH");
if (!gitSsh.isEmpty())
return QString::fromLocal8Bit(gitSsh);
#if QT_VERSION >= 0x050000
QString ssh = QStandardPaths::findExecutable(QLatin1String(defaultSshC));
#else
const Utils::Environment env = Utils::Environment::systemEnvironment();
QString ssh = env.searchInPath(QLatin1String(defaultSshC));
#endif
if (!ssh.isEmpty())
return ssh;
if (Utils::HostOsInfo::isWindowsHost()) { // Windows: Use ssh.exe from git if it cannot be found.
const QString git = GerritPlugin::gitBinary();
if (!git.isEmpty()) {
// Is 'git\cmd' in the path (folder containing .bats)?
QString path = QFileInfo(git).absolutePath();
if (path.endsWith(QLatin1String("cmd"), Qt::CaseInsensitive))
path.replace(path.size() - 3, 3, QLatin1String("bin"));
ssh = path + QLatin1Char('/') + QLatin1String(defaultSshC);
}
}
return ssh;
}
static QList<CMakeTool *> autoDetectCMakeTools()
{
QList<FileName> suspects;
Utils::Environment env = Environment::systemEnvironment();
QStringList path = env.path();
path.removeDuplicates();
QStringList execs = env.appendExeExtensions(QLatin1String("cmake"));
foreach (QString base, path) {
const QChar slash = QLatin1Char('/');
if (base.isEmpty())
continue;
// Avoid turning '/' into '//' on Windows which triggers Windows to check
// for network drives!
if (!base.endsWith(slash))
base += slash;
foreach (const QString &exec, execs) {
QFileInfo fi(base + exec);
if (fi.exists() && fi.isFile() && fi.isExecutable())
suspects << FileName::fromString(fi.absoluteFilePath());
}
}
QList<Utils::EnvironmentItem> RvctToolChainConfigWidget::environmentChanges() const
{
Utils::Environment baseEnv;
Utils::Environment resultEnv = baseEnvironment(static_cast<RvctToolChain *>(toolChain()));
resultEnv.modify(m_model->userChanges());
return baseEnv.diff(resultEnv);
}
bool AndroidPackageInstallationStep::init()
{
ProjectExplorer::BuildConfiguration *bc = buildConfiguration();
QString dirPath = bc->buildDirectory().appendPath(QLatin1String(Constants::ANDROID_BUILDDIRECTORY)).toString();
if (Utils::HostOsInfo::isWindowsHost())
if (bc->environment().searchInPath(QLatin1String("sh.exe")).isEmpty())
dirPath = QDir::toNativeSeparators(dirPath);
ProjectExplorer::ToolChain *tc
= ProjectExplorer::ToolChainKitInformation::toolChain(target()->kit());
ProjectExplorer::ProcessParameters *pp = processParameters();
pp->setMacroExpander(bc->macroExpander());
pp->setWorkingDirectory(bc->buildDirectory().toString());
pp->setCommand(tc->makeCommand(bc->environment()));
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->setArguments(QString::fromLatin1("INSTALL_ROOT=\"%1\" install").arg(dirPath));
pp->resolveAll();
setOutputParser(new ProjectExplorer::GnuMakeParser());
ProjectExplorer::IOutputParser *parser = target()->kit()->createOutputParser();
if (parser)
appendOutputParser(parser);
outputParser()->setWorkingDirectory(pp->effectiveWorkingDirectory());
m_androidDirToClean = dirPath;
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);
}
Utils::Environment MerQtVersion::qmakeRunEnvironment() const
{
Utils::Environment env = BaseQtVersion::qmakeRunEnvironment();
env.appendOrSet(QLatin1String(Constants::MER_SSH_TARGET_NAME),m_targetName);
env.appendOrSet(QLatin1String(Constants::MER_SSH_SDK_TOOLS),qmakeCommand().parentDir().toString());
return env;
}
Utils::Environment MsvcToolChain::readEnvironmentSetting(Utils::Environment& env) const
{
Utils::Environment result = env;
if (!QFileInfo::exists(m_vcvarsBat))
return result;
QMap<QString, QString> envPairs;
if (!generateEnvironmentSettings(env, m_vcvarsBat, m_varsBatArg, envPairs))
return result;
// Now loop through and process them
QMap<QString,QString>::const_iterator envIter;
for (envIter = envPairs.constBegin(); envIter!=envPairs.constEnd(); ++envIter) {
const QString expandedValue = winExpandDelayedEnvReferences(envIter.value(), env);
if (!expandedValue.isEmpty())
result.set(envIter.key(), expandedValue);
}
if (debug) {
const QStringList newVars = result.toStringList();
const QStringList oldVars = env.toStringList();
QDebug nsp = qDebug().nospace();
foreach (const QString &n, newVars) {
if (!oldVars.contains(n))
nsp << n << '\n';
}
}
return result;
}
// Note this functions is duplicated between AndroidDeployStep and AndroidDeployQtStep
// since it does modify the stored password in AndroidDeployQtStep it's not easily
// extractable. The situation will clean itself up once AndroidDeployStep is no longer
// necessary
QAbstractItemModel *AndroidDeployQtStep::keystoreCertificates()
{
QString rawCerts;
QProcess keytoolProc;
while (!rawCerts.length() || !m_keystorePasswd.length()) {
QStringList params;
params << QLatin1String("-list") << QLatin1String("-v") << QLatin1String("-keystore") << m_keystorePath.toUserOutput() << QLatin1String("-storepass");
if (!m_keystorePasswd.length())
keystorePassword();
if (!m_keystorePasswd.length())
return 0;
params << m_keystorePasswd;
Utils::Environment env = Utils::Environment::systemEnvironment();
env.set(QLatin1String("LANG"), QLatin1String("C"));
keytoolProc.setProcessEnvironment(env.toProcessEnvironment());
keytoolProc.start(AndroidConfigurations::instance().keytoolPath().toString(), params);
if (!keytoolProc.waitForStarted() || !keytoolProc.waitForFinished()) {
QMessageBox::critical(0, tr("Error"),
tr("Failed to run keytool"));
return 0;
}
if (keytoolProc.exitCode()) {
QMessageBox::critical(0, tr("Error"),
tr("Invalid password"));
m_keystorePasswd.clear();
}
rawCerts = QString::fromLatin1(keytoolProc.readAllStandardOutput());
}
return new CertificatesModel(rawCerts, this);
}
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();
// 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(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);
}
void QnxToolChain::addToEnvironment(Utils::Environment &env) const
{
if (env.value(QLatin1String("QNX_HOST")).isEmpty()
|| env.value(QLatin1String("QNX_TARGET")).isEmpty())
setQnxEnvironment(env, QnxUtils::qnxEnvironment(m_ndkPath));
GccToolChain::addToEnvironment(env);
}
void QnxQtVersion::addToEnvironment(const ProjectExplorer::Kit *k, Utils::Environment &env) const
{
QtSupport::BaseQtVersion::addToEnvironment(k, env);
updateEnvironment();
env.modify(m_qnxEnv);
env.prependOrSetLibrarySearchPath(qmakeProperty("QT_INSTALL_LIBS", PropertyVariantDev));
}
void QnxAbstractQtVersion::addToEnvironment(const ProjectExplorer::Kit *k, Utils::Environment &env) const
{
QtSupport::BaseQtVersion::addToEnvironment(k, env);
updateEnvironment();
env.modify(m_qnxEnv);
env.prependOrSetLibrarySearchPath(versionInfo().value(QLatin1String("QT_INSTALL_LIBS")));
}
void BuildConfiguration::updateCacheAndEmitEnvironmentChanged()
{
Utils::Environment env = baseEnvironment();
env.modify(userEnvironmentChanges());
if (env == m_cachedEnvironment)
return;
m_cachedEnvironment = env;
emit environmentChanged(); // might trigger buildDirectoryChanged signal!
}
QProcessEnvironment PuppetCreator::processEnvironment() const
{
Utils::Environment environment = Utils::Environment::systemEnvironment();
m_kit->addToEnvironment(environment);
environment.set("QML_BAD_GUI_RENDER_LOOP", "true");
environment.set("QML_USE_MOCKUPS", "true");
return environment.toProcessEnvironment();
}
static QString defaultCommand()
{
Utils::Environment env = Utils::Environment::systemEnvironment();
QString rc;
rc = QLatin1String("p4");
#if defined(Q_OS_WIN32)
rc.append(QLatin1String(".exe"));
#endif
return env.searchInPath(rc);
}
QList<HeaderPath> GccToolChain::systemHeaderPaths() const
{
if (m_headerPathes.isEmpty()) {
// Using a clean environment breaks ccache/distcc/etc.
Utils::Environment env = Utils::Environment::systemEnvironment();
addToEnvironment(env);
m_headerPathes = gccHeaderPathes(m_compilerPath, env.toStringList());
}
return m_headerPathes;
}
QByteArray GccToolChain::predefinedMacros() const
{
if (m_predefinedMacros.isEmpty()) {
// Using a clean environment breaks ccache/distcc/etc.
Utils::Environment env = Utils::Environment::systemEnvironment();
addToEnvironment(env);
m_predefinedMacros = gccPredefinedMacros(m_compilerPath, env.toStringList());
}
return m_predefinedMacros;
}
Utils::Environment QnxAbstractQtVersion::qmakeRunEnvironment() const
{
if (!sdkPath().isEmpty())
updateEnvironment();
Utils::Environment env = Utils::Environment::systemEnvironment();
env.modify(m_qnxEnv);
return env;
}
void SymbianQtVersion::addToEnvironment(const ProjectExplorer::Profile *p, Utils::Environment &env) const
{
BaseQtVersion::addToEnvironment(p, env);
// Generic Symbian environment:
QString epocRootPath = ProjectExplorer::SysRootProfileInformation::sysRoot(p).toString();
QDir epocDir(epocRootPath);
// Clean up epoc root path for the environment:
if (!epocRootPath.endsWith(QLatin1Char('/')))
epocRootPath.append(QLatin1Char('/'));
if (!isBuildWithSymbianSbsV2()) {
#ifdef Q_OS_WIN
if (epocRootPath.count() > 2
&& epocRootPath.at(0).toLower() >= QLatin1Char('a')
&& epocRootPath.at(0).toLower() <= QLatin1Char('z')
&& epocRootPath.at(1) == QLatin1Char(':')) {
epocRootPath = epocRootPath.mid(2);
}
#endif
}
env.set(QLatin1String("EPOCROOT"), QDir::toNativeSeparators(epocRootPath));
env.prependOrSetPath(epocDir.filePath(QLatin1String("epoc32/tools"))); // e.g. make.exe
// Windows only:
if (ProjectExplorer::Abi::hostAbi().os() == ProjectExplorer::Abi::WindowsOS) {
QString winDir = QLatin1String(qgetenv("WINDIR"));
if (!winDir.isEmpty())
env.prependOrSetPath(QDir(winDir).filePath(QLatin1String("system32")));
if (epocDir.exists(QLatin1String("epoc32/gcc/bin")))
env.prependOrSetPath(epocDir.filePath(QLatin1String("epoc32/gcc/bin"))); // e.g. cpp.exe, *NOT* gcc.exe
// Find perl in the special Symbian flavour:
if (epocDir.exists(QLatin1String("../../tools/perl/bin"))) {
epocDir.cd(QLatin1String("../../tools/perl/bin"));
env.prependOrSetPath(epocDir.absolutePath());
} else {
env.prependOrSetPath(epocDir.filePath(QLatin1String("perl/bin")));
}
}
// SBSv2:
if (isBuildWithSymbianSbsV2()) {
QString sbsHome(env.value(QLatin1String("SBS_HOME")));
QString sbsConfig = sbsV2Directory();
if (!sbsConfig.isEmpty()) {
env.prependOrSetPath(sbsConfig);
// SBS_HOME is the path minus the trailing /bin:
env.set(QLatin1String("SBS_HOME"),
QDir::toNativeSeparators(sbsConfig.left(sbsConfig.count() - 4))); // We need this for Qt 4.6.3 compatibility
} else if (!sbsHome.isEmpty()) {
env.prependOrSetPath(sbsHome + QLatin1String("/bin"));
}
}
}
void AbstractMaemoPackageCreationStep::preparePackagingProcess(QProcess *proc,
const Qt4BuildConfiguration *bc, const QString &workingDir)
{
Utils::Environment env = bc->environment();
if (bc->qmakeBuildConfiguration() & QtSupport::BaseQtVersion::DebugBuild) {
env.appendOrSet(QLatin1String("DEB_BUILD_OPTIONS"),
QLatin1String("nostrip"), QLatin1String(" "));
}
proc->setEnvironment(env.toStringList());
proc->setWorkingDirectory(workingDir);
}
ProjectExplorer::ToolChain *RvctToolChainFactory::create()
{
RvctToolChain *tc = new RvctToolChain(false);
Utils::Environment env = Utils::Environment::systemEnvironment();
if (env.hasKey(QLatin1String(RVCT_LICENSE_KEY))) {
tc->setEnvironmentChanges(QList<Utils::EnvironmentItem>()
<< Utils::EnvironmentItem(QLatin1String(RVCT_LICENSE_KEY),
env.value(QLatin1String(RVCT_LICENSE_KEY))));
}
tc->setDisplayName(tr("RVCT"));
return tc;
}
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 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()));
}
QString AndroidToolChain::makeCommand(const Utils::Environment &env) const
{
QStringList extraDirectories = AndroidConfigurations::currentConfig().makeExtraSearchDirectories();
if (HostOsInfo::isWindowsHost()) {
QString tmp = env.searchInPath(QLatin1String("ma-make.exe"), extraDirectories);
if (!tmp.isEmpty())
return tmp;
tmp = env.searchInPath(QLatin1String("mingw32-make"), extraDirectories);
return tmp.isEmpty() ? QLatin1String("mingw32-make") : tmp;
}
QString make = QLatin1String("make");
QString tmp = env.searchInPath(make, extraDirectories);
return tmp.isEmpty() ? make : tmp;
}
Abi GccToolChain::targetAbi() const
{
if (!m_targetAbi.isValid()) {
Utils::Environment env = Utils::Environment::systemEnvironment();
addToEnvironment(env);
m_targetAbi = guessGccAbi(m_compilerPath, env.toStringList());
m_supports64Bit = (m_targetAbi.wordWidth() == 64);
if (m_targetAbi.wordWidth() == 64 && m_forcedTo32Bit)
m_targetAbi = Abi(m_targetAbi.architecture(), m_targetAbi.os(), m_targetAbi.osFlavor(),
m_targetAbi.binaryFormat(), 32);
if (displayName() == typeName())
setDisplayName(defaultDisplayName());
}
return m_targetAbi;
}
Utils::Environment ExtraCompiler::buildEnvironment() const
{
if (Target *target = project()->activeTarget()) {
if (BuildConfiguration *bc = target->activeBuildConfiguration()) {
return bc->environment();
} else {
QList<Utils::EnvironmentItem> changes =
EnvironmentKitInformation::environmentChanges(target->kit());
Utils::Environment env = Utils::Environment::systemEnvironment();
env.modify(changes);
return env;
}
}
return Utils::Environment::systemEnvironment();
}
void GccToolChain::addToEnvironment(Utils::Environment &env) const
{
if (!m_compilerCommand.isEmpty()) {
Utils::FileName path = m_compilerCommand.parentDir();
env.prependOrSetPath(path.toString());
}
}
QList<ToolChain *> Internal::GccToolChainFactory::autoDetectToolchains(const QString &compiler,
const QStringList &debuggers,
const Abi &requiredAbi)
{
QList<ToolChain *> result;
const Utils::Environment systemEnvironment = Utils::Environment::systemEnvironment();
const QString compilerPath = systemEnvironment.searchInPath(compiler);
if (compilerPath.isEmpty())
return result;
QString debuggerPath; // Find the first debugger
foreach (const QString &debugger, debuggers) {
debuggerPath = systemEnvironment.searchInPath(debugger);
if (!debuggerPath.isEmpty())
break;
}
void GenericBuildConfiguration::addToEnvironment(Utils::Environment &env) const
{
prependCompilerPathToEnvironment(env);
const QtSupport::BaseQtVersion *qt = QtSupport::QtKitInformation::qtVersion(target()->kit());
if (qt)
env.prependOrSetPath(qt->binPath().toString());
}
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();
}