X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fsupport%2FSystemcall.cpp;h=7c4eaabc979490ae61930b290425582e83e262e5;hb=b198a36a363bb6a084407d476942d68ef5fb5e86;hp=2a1154cf2dbb97da069ec3e62628a199ca6ef25b;hpb=0c19763f600ce5100b1e66db736389be356e699b;p=lyx.git diff --git a/src/support/Systemcall.cpp b/src/support/Systemcall.cpp index 2a1154cf2d..7c4eaabc97 100644 --- a/src/support/Systemcall.cpp +++ b/src/support/Systemcall.cpp @@ -14,6 +14,8 @@ #include #include "support/debug.h" +#include "support/filetools.h" +#include "support/gettext.h" #include "support/lstrings.h" #include "support/qstring_helpers.h" #include "support/Systemcall.h" @@ -21,12 +23,13 @@ #include "support/os.h" #include "support/ProgressInterface.h" +#include "LyX.h" #include #include #include -#include +#include #include #include #include @@ -36,7 +39,7 @@ struct Sleep : QThread { - static void millisec(unsigned long ms) + static void millisec(unsigned long ms) { QThread::usleep(ms * 1000); } @@ -51,20 +54,31 @@ namespace lyx { namespace support { -class ProgressDummy : public ProgressInterface +class ProgressDummy : public ProgressInterface { public: ProgressDummy() {} - void processStarted(QString const &) {} - void processFinished(QString const &) {} - void appendMessage(QString const &) {} - void appendError(QString const &) {} - void clearMessages() {} + void processStarted(QString const &) override {} + void processFinished(QString const &) override {} + void appendMessage(QString const &) override {} + void appendError(QString const &) override {} + void clearMessages() override {} + void lyxerrFlush() override {} + + void lyxerrConnect() override {} + void lyxerrDisconnect() override {} + + void warning(QString const &, QString const &) override {} + void toggleWarning(QString const &, QString const &, QString const &) override {} + void error(QString const &, QString const &, QString const &) override {} + void information(QString const &, QString const &) override {} + int prompt(docstring const &, docstring const &, int default_but, int, + docstring const &, docstring const &) override { return default_but; } }; -static ProgressInterface* progress_instance = 0; +static ProgressInterface * progress_instance = nullptr; void ProgressInterface::setInstance(ProgressInterface* p) { @@ -72,7 +86,7 @@ void ProgressInterface::setInstance(ProgressInterface* p) } -ProgressInterface* ProgressInterface::instance() +ProgressInterface * ProgressInterface::instance() { if (!progress_instance) { static ProgressDummy dummy; @@ -87,9 +101,12 @@ ProgressInterface* ProgressInterface::instance() // Reuse of instance #ifndef USE_QPROCESS int Systemcall::startscript(Starttype how, string const & what, - bool /*process_events*/) + string const & path, string const & lpath, + bool /*process_events*/) { - string command = what; + string command = + to_filesystem8bit(from_utf8(latexEnvCmdPrefix(path, lpath))) + + commandPrep(what); if (how == DontWait) { switch (os::shell()) { @@ -100,7 +117,8 @@ int Systemcall::startscript(Starttype how, string const & what, command = "start /min " + command; break; } - } + } else if (os::shell() == os::CMD_EXE) + command = subst(command, "cmd /d /c ", ""); return ::system(command.c_str()); } @@ -110,8 +128,9 @@ int Systemcall::startscript(Starttype how, string const & what, namespace { /* - * This is a parser that (mostly) mimics the behavior of a posix shell but - * its output is tailored for being processed by QProcess. + * This is a parser that (mostly) mimics the behavior of a posix shell as + * regards quoting, but its output is tailored for being processed by QProcess. + * Note that shell metacharacters are not parsed. * * The escape character is the backslash. * A backslash that is not quoted preserves the literal value of the following @@ -144,83 +163,142 @@ namespace { * "\a" -> "\a" * "a\"b" -> "a"""b" */ -string const parsecmd(string const & inputcmd, string & outfile) +string const parsecmd(string const & incmd, string & infile, string & outfile, + string & errfile) { bool in_single_quote = false; bool in_double_quote = false; bool escaped = false; - string cmd; + string const python_call = os::python(); + vector outcmd(4); + size_t start = 0; + + if (prefixIs(incmd, python_call)) { + outcmd[0] = os::python(); + start = python_call.length(); + } - for (size_t i = 0; i < inputcmd.length(); ++i) { - char c = inputcmd[i]; + for (size_t i = start, o = 0; i < incmd.length(); ++i) { + char c = incmd[i]; if (c == '\'') { if (in_double_quote || escaped) { if (in_double_quote && escaped) - cmd += '\\'; - cmd += c; + outcmd[o] += '\\'; + outcmd[o] += c; } else in_single_quote = !in_single_quote; escaped = false; continue; } if (in_single_quote) { - cmd += c; + outcmd[o] += c; continue; } if (c == '"') { if (escaped) { - cmd += "\"\"\""; + // Don't triple double-quotes for redirection + // files as these won't be parsed by QProcess + outcmd[o] += string(o ? "\"" : "\"\"\""); escaped = false; } else { - cmd += c; + outcmd[o] += c; in_double_quote = !in_double_quote; } } else if (c == '\\' && !escaped) { - escaped = !escaped; + escaped = true; } else if (c == '>' && !(in_double_quote || escaped)) { - outfile = trim(inputcmd.substr(i + 1), " \""); - return trim(cmd); + if (suffixIs(outcmd[o], " 2")) { + outcmd[o] = rtrim(outcmd[o], "2"); + o = 2; + } else { + if (suffixIs(outcmd[o], " 1")) + outcmd[o] = rtrim(outcmd[o], "1"); + o = 1; + } + } else if (c == '<' && !(in_double_quote || escaped)) { + o = 3; +#if defined (USE_MACOSX_PACKAGING) + } else if (o == 0 && i > 4 && c == ' ' && !(in_double_quote || escaped)) { + // if a macOS app is detected with an additional argument + // use open command as prefix to get it work + const size_t apos = outcmd[o].rfind(".app"); + const size_t len = outcmd[o].length(); + const bool quoted = outcmd[o].at(len - 1) == '"' && outcmd[o].at(0) == '"'; + const string & ocmd = "open -a "; + if (apos != string::npos && + (apos == (len - 4) || (apos == (len - 5) && quoted)) && + !prefixIs(trim(outcmd[o]), ocmd)) { + outcmd[o] = ocmd + outcmd[o]; + } + outcmd[o] += c; +#endif } else { if (escaped && in_double_quote) - cmd += '\\'; - cmd += c; + outcmd[o] += '\\'; + outcmd[o] += c; escaped = false; } } - outfile.erase(); - return cmd; + infile = trim(outcmd[3], " \""); + outfile = trim(outcmd[1], " \""); + errfile = trim(outcmd[2], " \""); + return trim(outcmd[0]); } -} // namespace anon - +} // namespace -int Systemcall::startscript(Starttype how, string const & what, bool process_events) +void Systemcall::killscript() { - string outfile; - QString cmd = toqstr(parsecmd(what, outfile)); - - SystemcallPrivate d(outfile); + SystemcallPrivate::kill_script = true; +} - d.startProcess(cmd); - if (!d.waitWhile(SystemcallPrivate::Starting, process_events, -1)) { - LYXERR0("Systemcall: '" << cmd << "' did not start!"); - LYXERR0("error " << d.errorMessage()); - return 10; - } +int Systemcall::startscript(Starttype how, string const & what, + string const & path, string const & lpath, + bool process_events) +{ + string const what_ss = commandPrep(what); + if (verbose) + lyxerr << "\nRunning: " << what_ss << endl; + else + LYXERR(Debug::INFO,"Running: " << what_ss); - if (how == DontWait) { - QProcess* released = d.releaseProcess(); - (void) released; // TODO who deletes it? - return 0; + string infile; + string outfile; + string errfile; + QString const cmd = QString::fromLocal8Bit( + parsecmd(what_ss, infile, outfile, errfile).c_str()); + + SystemcallPrivate d(infile, outfile, errfile); + bool do_events = process_events || how == WaitLoop; + + d.startProcess(cmd, path, lpath, how == DontWait); + if (how == DontWait && d.state == SystemcallPrivate::Running) + return OK; + + if (d.state == SystemcallPrivate::Error + || !d.waitWhile(SystemcallPrivate::Starting, do_events, -1)) { + if (d.state == SystemcallPrivate::Error) { + LYXERR0("Systemcall: '" << cmd << "' did not start!"); + LYXERR0("error " << d.errorMessage()); + return NOSTART; + } else if (d.state == SystemcallPrivate::Killed) { + LYXERR0("Killed: " << cmd); + return KILLED; + } } - if (!d.waitWhile(SystemcallPrivate::Running, process_events, 180000)) { - LYXERR0("Systemcall: '" << cmd << "' did not finished!"); + if (!d.waitWhile(SystemcallPrivate::Running, do_events, + os::timeout_ms())) { + if (d.state == SystemcallPrivate::Killed) { + LYXERR0("Killed: " << cmd); + return KILLED; + } + LYXERR0("Systemcall: '" << cmd << "' did not finish!"); LYXERR0("error " << d.errorMessage()); LYXERR0("status " << d.exitStatusMessage()); - return 20; + return TIMEOUT; } int const exit_code = d.exitCode(); @@ -232,104 +310,243 @@ int Systemcall::startscript(Starttype how, string const & what, bool process_eve } -SystemcallPrivate::SystemcallPrivate(const std::string& of) : - proc_(new QProcess), outindex_(0), errindex_(0), - outfile(of), showout_(false), showerr_(false), process_events(false) +bool SystemcallPrivate::kill_script = false; + + +SystemcallPrivate::SystemcallPrivate(std::string const & sf, std::string const & of, + std::string const & ef) + : state(Error), process_(new QProcess), out_index_(0), err_index_(0), + in_file_(sf), out_file_(of), err_file_(ef), process_events_(false) { - if (!outfile.empty()) { - // Check whether we have to simply throw away the output. - if (outfile != os::nulldev()) - proc_->setStandardOutputFile(toqstr(outfile)); - } else if (os::is_terminal(os::STDOUT)) - setShowOut(true); - if (os::is_terminal(os::STDERR)) - setShowErr(true); - - connect(proc_, SIGNAL(readyReadStandardOutput()), SLOT(stdOut())); - connect(proc_, SIGNAL(readyReadStandardError()), SLOT(stdErr())); - connect(proc_, SIGNAL(error(QProcess::ProcessError)), SLOT(processError(QProcess::ProcessError))); - connect(proc_, SIGNAL(started()), this, SLOT(processStarted())); - connect(proc_, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(processFinished(int, QProcess::ExitStatus))); -} + if (!in_file_.empty()) + process_->setStandardInputFile(QString::fromLocal8Bit(in_file_.c_str())); + if (!out_file_.empty()) { + if (out_file_[0] == '&') { + if (subst(out_file_, " ", "") == "&2" + && err_file_[0] != '&') { + out_file_ = err_file_; + process_->setProcessChannelMode( + QProcess::MergedChannels); + } else { + if (err_file_[0] == '&') { + // Leave alone things such as + // "1>&2 2>&1". Should not be harmful, + // but let's give anyway a warning. + LYXERR0("Unsupported stdout/stderr redirect."); + err_file_.erase(); + } else { + LYXERR0("Ambiguous stdout redirect: " + << out_file_); + } + out_file_ = os::nulldev(); + } + } + // Check whether we have to set the output file. + if (out_file_ != os::nulldev()) { + process_->setStandardOutputFile(QString::fromLocal8Bit( + out_file_.c_str())); + } + } + if (!err_file_.empty()) { + if (err_file_[0] == '&') { + if (subst(err_file_, " ", "") == "&1" + && out_file_[0] != '&') { + process_->setProcessChannelMode( + QProcess::MergedChannels); + } else { + LYXERR0("Ambiguous stderr redirect: " + << err_file_); + } + // In MergedChannels mode stderr goes to stdout. + err_file_ = os::nulldev(); + } + // Check whether we have to set the error file. + if (err_file_ != os::nulldev()) { + process_->setStandardErrorFile(QString::fromLocal8Bit( + err_file_.c_str())); + } + } + connect(process_, SIGNAL(readyReadStandardOutput()), SLOT(stdOut())); + connect(process_, SIGNAL(readyReadStandardError()), SLOT(stdErr())); +#if QT_VERSION >= 0x050600 + connect(process_, SIGNAL(errorOccurred(QProcess::ProcessError)), SLOT(processError(QProcess::ProcessError))); +#else + connect(process_, SIGNAL(error(QProcess::ProcessError)), SLOT(processError(QProcess::ProcessError))); +#endif + connect(process_, SIGNAL(started()), this, SLOT(processStarted())); + connect(process_, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(processFinished(int, QProcess::ExitStatus))); +} -void SystemcallPrivate::startProcess(const QString& cmd) +void SystemcallPrivate::startProcess(QString const & cmd, string const & path, + string const & lpath, bool detached) { cmd_ = cmd; - if (proc_) { +#if (QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)) + // FIXME pass command and arguments separated in the first place + /* The versions of startDetached() and start() that accept a + * QStringList object exist since Qt4, but it is only in Qt 5.15 + * that splitCommand() was introduced and the plain versions of + * start/startDetached() have been deprecated. + * The cleanest solution would be to have parsecmd() produce a + * QStringList for arguments, instead of transforming the string + * into something that the QProcess splitter accepts. + * + * Another reason for doing that is that the Qt parser ignores + * empty "" arguments, which are needed in some instances (see + * e.g. the work around for modules in Converter:convert. See + * QTBUG-80640 for a discussion. + */ + QStringList arguments = QProcess::splitCommand(toqstr(latexEnvCmdPrefix(path, lpath)) + cmd_); + QString command = (arguments.empty()) ? QString() : arguments.first(); + if (arguments.size() == 1) + arguments.clear(); + else if (!arguments.empty()) + arguments.removeFirst(); +#endif + if (detached) { + state = SystemcallPrivate::Running; +#ifdef Q_OS_WIN32 + // Avoid opening a console window when a viewer is started + if (in_file_.empty()) + process_->setStandardInputFile(QProcess::nullDevice()); + if (out_file_.empty()) + process_->setStandardOutputFile(QProcess::nullDevice()); + if (err_file_.empty()) + process_->setStandardErrorFile(QProcess::nullDevice()); +#endif +#if (QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)) + if (!QProcess::startDetached(command, arguments)) { +#else + if (!QProcess::startDetached(toqstr(latexEnvCmdPrefix(path, lpath)) + cmd_)) { +#endif + state = SystemcallPrivate::Error; + return; + } + QProcess* released = releaseProcess(); + delete released; + } else if (process_) { state = SystemcallPrivate::Starting; - proc_->start(cmd_); +#if (QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)) + process_->start(command, arguments); +#else + process_->start(toqstr(latexEnvCmdPrefix(path, lpath)) + cmd_); +#endif } } -void SystemcallPrivate::processEvents() +bool SystemcallPrivate::waitAndCheck() { - if(process_events) { - QCoreApplication::processEvents(/*QEventLoop::ExcludeUserInputEvents*/); + Sleep::millisec(100); + if (kill_script) { + // is there a better place to reset this? + process_->kill(); + state = Killed; + kill_script = false; + LYXERR0("Export Canceled!!"); + return false; } + QCoreApplication::processEvents(/*QEventLoop::ExcludeUserInputEvents*/); + return true; } -void SystemcallPrivate::waitAndProcessEvents() +namespace { + +bool queryStopCommand(QString const & cmd) { - Sleep::millisec(100); - processEvents(); + docstring text = bformat(_( + "The command\n%1$s\nhas not yet completed.\n\n" + "Do you want to stop it?"), qstring_to_ucs4(cmd)); + return ProgressInterface::instance()->prompt(_("Stop command?"), text, + 1, 1, _("&Stop it"), _("Let it &run")) == 0; } +} // namespace + -bool SystemcallPrivate::waitWhile(State waitwhile, bool proc_events, int timeout) +bool SystemcallPrivate::waitWhile(State waitwhile, bool process_events, int timeout) { - if (!proc_) + if (!process_) return false; - process_events = proc_events; + bool timedout = false; + process_events_ = process_events; // Block GUI while waiting, // relay on QProcess' wait functions - if (!process_events) { + if (!process_events_) { if (waitwhile == Starting) - return proc_->waitForStarted(timeout); - if (waitwhile == Running) - return proc_->waitForFinished(timeout); + return process_->waitForStarted(timeout); + if (waitwhile == Running) { + int bump = 2; + while (!timedout) { + if (process_->waitForFinished(timeout)) + return true; + bool const stop = queryStopCommand(cmd_); + // The command may have finished in the meantime + if (process_->state() == QProcess::NotRunning) + return true; + if (stop) { + timedout = true; + process_->kill(); + } else { + timeout *= bump; + bump = 3; + } + } + } return false; } // process events while waiting, no timeout if (timeout == -1) { while (state == waitwhile && state != Error) { - waitAndProcessEvents(); + // check for cancellation of background process + if (!waitAndCheck()) + return false; } return state != Error; - } + } - // process events while waiting whith timeout - QTime timer; + // process events while waiting with timeout + QElapsedTimer timer; timer.start(); - while (state == waitwhile && state != Error && timer.elapsed() < timeout) { - waitAndProcessEvents(); + while (state == waitwhile && state != Error && !timedout) { + // check for cancellation of background process + if (!waitAndCheck()) + return false; + + if (timer.elapsed() > timeout) { + bool const stop = queryStopCommand(cmd_); + // The command may have finished in the meantime + if (process_->state() == QProcess::NotRunning) + break; + if (stop) { + timedout = true; + process_->kill(); + } else + timeout *= 3; + } } - return (state != Error) && (timer.elapsed() < timeout); + return (state != Error) && !timedout; } SystemcallPrivate::~SystemcallPrivate() { - flush(); - - if (outindex_) { - outdata_[outindex_] = '\0'; - outindex_ = 0; - if (showout_) - cout << outdata_; + if (out_index_) { + out_data_[out_index_] = '\0'; + out_index_ = 0; + cout << out_data_; } cout.flush(); - if (errindex_) { - errdata_[errindex_] = '\0'; - errindex_ = 0; - if (showerr_) - cerr << errdata_; + if (err_index_) { + err_data_[err_index_] = '\0'; + err_index_ = 0; + cerr << err_data_; } cerr.flush(); @@ -337,77 +554,57 @@ SystemcallPrivate::~SystemcallPrivate() } -void SystemcallPrivate::flush() -{ - if (proc_) { - // If the output has been redirected, we write it all at once. - // Even if we are not running in a terminal, the output could go - // to some log file, for example ~/.xsession-errors on *nix. - if (!os::is_terminal(os::STDOUT) && outfile.empty()) - cout << fromqstr(QString::fromLocal8Bit( - proc_->readAllStandardOutput().data())); - if (!os::is_terminal(os::STDERR)) - cerr << fromqstr(QString::fromLocal8Bit( - proc_->readAllStandardError().data())); - } -} - - void SystemcallPrivate::stdOut() { - if (proc_) { + if (process_) { char c; - proc_->setReadChannel(QProcess::StandardOutput); - while (proc_->getChar(&c)) { - outdata_[outindex_++] = c; - if (c == '\n' || outindex_ + 1 == bufsize_) { - outdata_[outindex_] = '\0'; - outindex_ = 0; - if (showout_) - cout << outdata_; + process_->setReadChannel(QProcess::StandardOutput); + while (process_->getChar(&c)) { + out_data_[out_index_++] = c; + if (c == '\n' || out_index_ + 1 == buffer_size_) { + out_data_[out_index_] = '\0'; + out_index_ = 0; + ProgressInterface::instance()->appendMessage(QString::fromLocal8Bit(out_data_)); + cout << out_data_; } } } - const QString data = QString::fromLocal8Bit(outdata_); - if (!data.isEmpty()) - ProgressInterface::instance()->appendMessage(data); - processEvents(); } void SystemcallPrivate::stdErr() { - if (proc_) { + if (process_) { char c; - proc_->setReadChannel(QProcess::StandardError); - while (proc_->getChar(&c)) { - errdata_[errindex_++] = c; - if (c == '\n' || errindex_ + 1 == bufsize_) { - errdata_[errindex_] = '\0'; - errindex_ = 0; - if (showerr_) - cerr << errdata_; + process_->setReadChannel(QProcess::StandardError); + while (process_->getChar(&c)) { + err_data_[err_index_++] = c; + if (c == '\n' || err_index_ + 1 == buffer_size_) { + err_data_[err_index_] = '\0'; + err_index_ = 0; + ProgressInterface::instance()->appendError(QString::fromLocal8Bit(err_data_)); + cerr << err_data_; } } } - const QString data = QString::fromLocal8Bit(errdata_); - if (!data.isEmpty()) - ProgressInterface::instance()->appendError(data); - processEvents(); } void SystemcallPrivate::processStarted() { - state = Running; - ProgressInterface::instance()->processStarted(cmd_); + if (state != Running) { + state = Running; + ProgressInterface::instance()->processStarted(cmd_); + } } void SystemcallPrivate::processFinished(int, QProcess::ExitStatus) { - state = Finished; - ProgressInterface::instance()->processFinished(cmd_); + if (state != Finished) { + state = Finished; + ProgressInterface::instance()->processFinished(cmd_); + } } @@ -418,13 +615,13 @@ void SystemcallPrivate::processError(QProcess::ProcessError) } -QString SystemcallPrivate::errorMessage() const +QString SystemcallPrivate::errorMessage() const { - if (!proc_) + if (!process_) return "No QProcess available"; QString message; - switch (proc_->error()) { + switch (process_->error()) { case QProcess::FailedToStart: message = "The process failed to start. Either the invoked program is missing, " "or you may have insufficient permissions to invoke the program."; @@ -445,7 +642,7 @@ QString SystemcallPrivate::errorMessage() const break; case QProcess::UnknownError: default: - message = "An unknown error occured."; + message = "An unknown error occurred."; break; } return message; @@ -454,11 +651,11 @@ QString SystemcallPrivate::errorMessage() const QString SystemcallPrivate::exitStatusMessage() const { - if (!proc_) + if (!process_) return "No QProcess available"; QString message; - switch (proc_->exitStatus()) { + switch (process_->exitStatus()) { case QProcess::NormalExit: message = "The process exited normally."; break; @@ -475,24 +672,26 @@ QString SystemcallPrivate::exitStatusMessage() const int SystemcallPrivate::exitCode() { - if (!proc_) + // From Qt's documentation, in regards to QProcess::exitCode(), + // "This value is not valid unless exitStatus() returns NormalExit" + if (!process_ || process_->exitStatus() != QProcess::NormalExit) return -1; - return proc_->exitCode(); + return process_->exitCode(); } QProcess* SystemcallPrivate::releaseProcess() { - QProcess* released = proc_; - proc_ = 0; + QProcess* released = process_; + process_ = nullptr; return released; } void SystemcallPrivate::killProcess() { - killProcess(proc_); + killProcess(process_); }