thinko

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

diff --git a/src/support/ForkedCalls.cpp b/src/support/ForkedCalls.cpp
index 9957af2119e1f74ca50f380da10dabffe0324c27..1318bd3ec2910156eb548e47f79c3711eb65261a 100644 (file)
--- a/src/support/ForkedCalls.cpp
+++ b/src/support/ForkedCalls.cpp
@@ -47,7 +47,6 @@
 using namespace std;
 
 
-
 namespace lyx {
 namespace support {
 
@@ -59,7 +58,7 @@ namespace {
 //
 /////////////////////////////////////////////////////////////////////
 
-class Murder : public boost::signals::trackable {
+class Murder {
 public:
        //
        static void killItDead(int secs, pid_t pid)
@@ -84,7 +83,8 @@ private:
        Murder(int secs, pid_t pid)
                : timeout_(1000*secs, Timeout::ONETIME), pid_(pid)
        {
-               timeout_.timeout.connect(lyx::bind(&Murder::kill, this));
+               // Connection is closed with this.
+               timeout_.timeout.connect([this](){ kill(); });
                timeout_.start();
        }
 
@@ -94,7 +94,7 @@ private:
        pid_t pid_;
 };
 
-} // namespace anon
+} // namespace
 
 
 /////////////////////////////////////////////////////////////////////
@@ -113,7 +113,7 @@ bool ForkedProcess::IAmAChild = false;
 
 void ForkedProcess::emitSignal()
 {
-       if (signal_.get()) {
+       if (signal_) {
                signal_->operator()(pid_, retval_);
        }
 }
@@ -129,7 +129,7 @@ int ForkedProcess::run(Starttype type)
                if (pid_ == 0)
                        //we also do this in fork(), too, but maybe someone will try
                        //to bypass that
-                       IAmAChild = true; 
+                       IAmAChild = true;
                return retval_;
        }
 
@@ -270,27 +270,27 @@ int ForkedProcess::waitForChild()
 //
 /////////////////////////////////////////////////////////////////////
 
-ForkedCall::ForkedCall(string const & path)
-       : cmd_prefix_(to_filesystem8bit(from_utf8(latexEnvCmdPrefix(path))))
+ForkedCall::ForkedCall(string const & path, string const & lpath)
+       : cmd_prefix_(to_filesystem8bit(from_utf8(latexEnvCmdPrefix(path, lpath))))
 {}
 
 
 int ForkedCall::startScript(Starttype wait, string const & what)
 {
        if (wait != Wait) {
-               retval_ = startScript(what, SignalTypePtr());
+               retval_ = startScript(what, sigPtr());
                return retval_;
        }
 
-       command_ = what;
+       command_ = commandPrep(trim(what));
        signal_.reset();
        return run(Wait);
 }
 
 
-int ForkedCall::startScript(string const & what, SignalTypePtr signal)
+int ForkedCall::startScript(string const & what, sigPtr signal)
 {
-       command_ = what;
+       command_ = commandPrep(trim(what));
        signal_  = signal;
 
        return run(DontWait);
@@ -300,10 +300,14 @@ int ForkedCall::startScript(string const & what, SignalTypePtr signal)
 // generate child in background
 int ForkedCall::generateChild()
 {
-       string const line = trim(cmd_prefix_ + command_);
-       if (line.empty())
+       if (command_.empty())
                return 1;
 
+       // Make sure that a V2 python is run, if available.
+       string const line = cmd_prefix_ +
+               (prefixIs(command_, "python -tt")
+                ? os::python() + command_.substr(10) : command_);
+
 #if !defined (_WIN32)
        // POSIX
 
@@ -370,14 +374,14 @@ int ForkedCall::generateChild()
                        argv.push_back(&*it);
                prev = *it;
        }
-       argv.push_back(0);
+       argv.push_back(nullptr);
 
        // Debug output.
        if (lyxerr.debugging(Debug::FILES)) {
                vector<char *>::iterator ait = argv.begin();
                vector<char *>::iterator const aend = argv.end();
                lyxerr << "<command>\n\t" << line
-                      << "\n\tInterpretted as:\n\n";
+                      << "\n\tInterpreted as:\n\n";
                for (; ait != aend; ++ait)
                        if (*ait)
                                lyxerr << '\t'<< *ait << '\n';
@@ -399,12 +403,12 @@ int ForkedCall::generateChild()
 
        pid_t cpid = -1;
 
-       STARTUPINFO startup; 
-       PROCESS_INFORMATION process; 
+       STARTUPINFO startup;
+       PROCESS_INFORMATION process;
 
        memset(&startup, 0, sizeof(STARTUPINFO));
        memset(&process, 0, sizeof(PROCESS_INFORMATION));
-    
+
        startup.cb = sizeof(STARTUPINFO);
 
        if (CreateProcess(0, (LPSTR)line.c_str(), 0, 0, FALSE,
@@ -432,13 +436,13 @@ int ForkedCall::generateChild()
 namespace ForkedCallQueue {
 
 /// A process in the queue
-typedef pair<string, ForkedCall::SignalTypePtr> Process;
+typedef pair<string, ForkedCall::sigPtr> Process;
 /** Add a process to the queue. Processes are forked sequentially
  *  only one is running at a time.
  *  Connect to the returned signal and you'll be informed when
  *  the process has ended.
  */
-ForkedCall::SignalTypePtr add(string const & process);
+ForkedCall::sigPtr add(string const & process);
 
 /// in-progress queue
 static queue<Process> callQueue_;
@@ -453,10 +457,10 @@ void stopCaller();
 ///
 void callback(pid_t, int);
 
-ForkedCall::SignalTypePtr add(string const & process)
+ForkedCall::sigPtr add(string const & process)
 {
-       ForkedCall::SignalTypePtr ptr;
-       ptr.reset(new ForkedCall::SignalType);
+       ForkedCall::sigPtr ptr;
+       ptr.reset(new ForkedCall::sig);
        callQueue_.push(Process(process, ptr));
        if (!running_)
                startCaller();
@@ -471,7 +475,7 @@ void callNext()
        Process pro = callQueue_.front();
        callQueue_.pop();
        // Bind our chain caller
-       pro.second->connect(lyx::bind(&ForkedCallQueue::callback, _1, _2));
+       pro.second->connect(callback);
        ForkedCall call;
        //If we fail to fork the process, then emit the signal
        //to tell the outside world that it failed.
@@ -509,8 +513,7 @@ bool running()
        return running_;
 }
 
-} // namespace ForkedCallsQueue
-
+} // namespace ForkedCallQueue
 
 
 /////////////////////////////////////////////////////////////////////