add onoff support for "inset-modify changetype xxx" in include inset

[lyx.git] / src / support / Systemcall.cpp

diff --git a/src/support/Systemcall.cpp b/src/support/Systemcall.cpp
index 1692b2ca1c8e88bf488872b7bff69622f27f25ad..e51fc169ca16350259b06a9070ec973b94492788 100644 (file)
--- a/src/support/Systemcall.cpp
+++ b/src/support/Systemcall.cpp
@@ -14,8 +14,10 @@
 #include <config.h>
 
 #include "support/debug.h"
+#include "support/lstrings.h"
 #include "support/qstring_helpers.h"
 #include "support/Systemcall.h"
+#include "support/SystemcallPrivate.h"
 #include "support/os.h"
 
 #include <cstdlib>
@@ -23,7 +25,7 @@
 
 #include <QProcess>
 
-#define DISABLE_EVALUATE_QPROCESS
+#define USE_QPROCESS
 
 using namespace std;
 
@@ -32,6 +34,7 @@ namespace support {
 
 static void killProcess(QProcess * p)
 {
+       p->disconnect();
        p->closeReadChannel(QProcess::StandardOutput);
        p->closeReadChannel(QProcess::StandardError);
        p->close();
@@ -40,9 +43,9 @@ static void killProcess(QProcess * p)
 
 
 // Reuse of instance
+#ifndef USE_QPROCESS
 int Systemcall::startscript(Starttype how, string const & what)
 {
-#ifdef DISABLE_EVALUATE_QPROCESS
        string command = what;
 
        if (how == DontWait) {
@@ -57,21 +60,65 @@ int Systemcall::startscript(Starttype how, string const & what)
        }
 
        return ::system(command.c_str());
+}
+
 #else
-       QString cmd = QString::fromLocal8Bit(what.c_str());
+
+namespace {
+
+string const parsecmd(string const & cmd, string & outfile)
+{
+       bool inquote = false;
+       bool escaped = false;
+
+       for (size_t i = 0; i < cmd.length(); ++i) {
+               char c = cmd[i];
+               if (c == '"' && !escaped)
+                       inquote = !inquote;
+               else if (c == '\\' && !escaped)
+                       escaped = !escaped;
+               else if (c == '>' && !(inquote || escaped)) {
+                       outfile = trim(cmd.substr(i + 1), " \"");
+                       return trim(cmd.substr(0, i));
+               } else
+                       escaped = false;
+       }
+       outfile.erase();
+       return cmd;
+}
+
+} // namespace anon
+
+
+int Systemcall::startscript(Starttype how, string const & what)
+{
+       string outfile;
+       QString cmd = toqstr(parsecmd(what, outfile));
        QProcess * process = new QProcess;
+       ConOut console(process);
+       if (!outfile.empty()) {
+               // Check whether we have to simply throw away the output.
+               if (outfile != os::nulldev())
+                       process->setStandardOutputFile(toqstr(outfile));
+       } else if (os::is_terminal(os::STDOUT))
+               console.showout();
+       if (os::is_terminal(os::STDERR))
+               console.showerr();
+
        process->start(cmd);
-       if (!process->waitForStarted(1000)) {
+       if (!process->waitForStarted(3000)) {
                LYXERR0("Qprocess " << cmd << " did not start!");
                LYXERR0("error " << process->error());
                LYXERR0("state " << process->state());
                LYXERR0("status " << process->exitStatus());
                return 10;
        }
-       if (how == DontWait)
+       if (how == DontWait) {
+               // TODO delete process later
                return 0;
+       }
 
-       if (!process->waitForFinished(30000)) {
+       if (!process->waitForFinished(180000)) {
                LYXERR0("Qprocess " << cmd << " did not finished!");
                LYXERR0("error " << process->error());
                LYXERR0("state " << process->state());
@@ -86,12 +133,82 @@ int Systemcall::startscript(Starttype how, string const & what)
                LYXERR0("state " << process->state());
                LYXERR0("status " << process->exitStatus());
        }
-       cout << fromqstr(QString::fromLocal8Bit(process->readAllStandardOutput().data())) << endl;
-       cerr << fromqstr(QString::fromLocal8Bit(process->readAllStandardError().data())) << endl;
+
+       // 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(
+                           process->readAllStandardOutput().data()));
+       if (!os::is_terminal(os::STDERR))
+               cerr << fromqstr(QString::fromLocal8Bit(
+                           process->readAllStandardError().data()));
+
        killProcess(process);
        return exit_code;
-#endif
 }
 
+
+ConOut::ConOut(QProcess * proc) : proc_(proc), outindex_(0), errindex_(0),
+                                 showout_(false), showerr_(false)
+{
+       connect(proc, SIGNAL(readyReadStandardOutput()), SLOT(stdOut()));
+       connect(proc, SIGNAL(readyReadStandardError()), SLOT(stdErr()));
+}
+
+
+ConOut::~ConOut()
+{
+       if (outindex_) {
+               outdata_[outindex_] = '\0';
+               outindex_ = 0;
+               cout << outdata_;
+       }
+       cout.flush();
+       if (errindex_) {
+               errdata_[errindex_] = '\0';
+               errindex_ = 0;
+               cerr << errdata_;
+       }
+       cerr.flush();
+}
+
+
+void ConOut::stdOut()
+{
+       if (showout_) {
+               char c;
+               proc_->setReadChannel(QProcess::StandardOutput);
+               while (proc_->getChar(&c)) {
+                       outdata_[outindex_++] = c;
+                       if (c == '\n' || outindex_ + 1 == bufsize_) {
+                               outdata_[outindex_] = '\0';
+                               outindex_ = 0;
+                               cout << outdata_;
+                       }
+               }
+       }
+}
+
+
+void ConOut::stdErr()
+{
+       if (showerr_) {
+               char c;
+               proc_->setReadChannel(QProcess::StandardError);
+               while (proc_->getChar(&c)) {
+                       errdata_[errindex_++] = c;
+                       if (c == '\n' || errindex_ + 1 == bufsize_) {
+                               errdata_[errindex_] = '\0';
+                               errindex_ = 0;
+                               cerr << errdata_;
+                       }
+               }
+       }
+}
+
+#include "moc_SystemcallPrivate.cpp"
+#endif
+
 } // namespace support
 } // namespace lyx