#include "support/ForkedCalls.h"
#include "support/debug.h"
-#include "support/environment.h"
#include "support/filetools.h"
#include "support/lstrings.h"
#include "support/lyxlib.h"
#include "support/bind.h"
-#include "LyXRC.h"
-
#include <cerrno>
+#include <cstring>
+#include <list>
#include <queue>
#include <sstream>
#include <utility>
using namespace std;
-
namespace lyx {
namespace support {
//
/////////////////////////////////////////////////////////////////////
-class Murder : public boost::signals::trackable {
+class Murder {
public:
//
static void killItDead(int secs, pid_t pid)
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();
}
pid_t pid_;
};
-} // namespace anon
+} // namespace
/////////////////////////////////////////////////////////////////////
void ForkedProcess::emitSignal()
{
- if (signal_.get()) {
+ if (signal_) {
signal_->operator()(pid_, retval_);
}
}
if (pid_ == 0)
//we also do this in fork(), too, but maybe someone will try
//to bypass that
- IAmAChild = true;
+ IAmAChild = true;
return retval_;
}
//
/////////////////////////////////////////////////////////////////////
-ForkedCall::ForkedCall(string const & path)
- : cmd_prefix_(empty_string())
-{
- if (path.empty() || lyxrc.texinputs_prefix.empty())
- return;
-
- string const texinputs = os::latex_path_list(
- replaceCurdirPath(path, lyxrc.texinputs_prefix));
- string const sep = string(1, os::path_separator(os::TEXENGINE));
- string const env = getEnv("TEXINPUTS");
-
- if (os::shell() == os::UNIX)
- cmd_prefix_ = "env 'TEXINPUTS=." + sep + texinputs
- + sep + env + "' ";
- else
- cmd_prefix_ = "cmd /d /c set TEXINPUTS=." + sep + texinputs
- + sep + env + " & ";
-}
+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);
// 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
// 2. If we are inside quotes, then don't replace the white space
// but do remove the quotes themselves. We do this naively by
// replacing the quote with '\0' which is fine if quotes
- // delimit the entire word.
+ // delimit the entire word. However, if quotes do not delimit the
+ // entire word (i.e., open quote is inside word), simply discard
+ // them such as not to break the current word.
char inside_quote = 0;
+ char c_before_open_quote = ' ';
vector<char>::iterator it = vec.begin();
+ vector<char>::iterator itc = vec.begin();
vector<char>::iterator const end = vec.end();
- for (; it != end; ++it) {
+ for (; it != end; ++it, ++itc) {
char const c = *it;
if (!inside_quote) {
- if (c == ' ')
- *it = '\0';
- else if (c == '\'' || c == '"') {
- *it = '\0';
+ if (c == '\'' || c == '"') {
+ if (c_before_open_quote == ' ')
+ *itc = '\0';
+ else
+ --itc;
inside_quote = c;
+ } else {
+ if (c == ' ')
+ *itc = '\0';
+ else
+ *itc = c;
+ c_before_open_quote = c;
}
} else if (c == inside_quote) {
- *it = '\0';
+ if (c_before_open_quote == ' ')
+ *itc = '\0';
+ else
+ --itc;
inside_quote = 0;
- }
+ } else
+ *itc = c;
}
+ // Clear what remains.
+ for (; itc != end; ++itc)
+ *itc = '\0';
+
// Build an array of pointers to each word.
it = vec.begin();
vector<char *> argv;
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';
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,
namespace ForkedCallQueue {
/// A process in the queue
-typedef pair<string, ForkedCall::SignalTypePtr> 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);
+typedef pair<string, ForkedCall::sigPtr> Process;
/// in-progress queue
static queue<Process> callQueue_;
/// flag whether queue is running
-static bool running_ = 0;
+static bool running_ = false;
///
void startCaller();
///
void callback(pid_t, int);
-ForkedCall::SignalTypePtr add(string const & 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::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();
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.
return running_;
}
-} // namespace ForkedCallsQueue
-
+} // namespace ForkedCallQueue
/////////////////////////////////////////////////////////////////////
forkedCalls.erase(it);
actCall->emitSignal();
- /* start all over: emiting the signal can result
+ /* start all over: emitting the signal can result
* in changing the list (Ab)
*/
it = forkedCalls.begin();