#include "Converter.h"
#include "Buffer.h"
-#include "buffer_funcs.h"
#include "BufferParams.h"
#include "ConverterCache.h"
+#include "TextClass.h"
#include "Encoding.h"
#include "ErrorList.h"
#include "Format.h"
#include "LaTeX.h"
#include "LyXRC.h"
#include "Mover.h"
+#include "OutputParams.h"
#include "ParagraphList.h"
#include "Session.h"
string const token_path("$$p");
string const token_orig_path("$$r");
string const token_orig_from("$$f");
+string const token_textclass("$$c");
+string const token_modules("$$m");
string const token_encoding("$$e");
string const token_latex_encoding("$$E");
-
+string const token_python("$${python}");
string const add_options(string const & command, string const & options)
{
Converter::Converter(string const & f, string const & t,
string const & c, string const & l)
: from_(f), to_(t), command_(c), flags_(l),
- From_(0), To_(0), latex_(false), xml_(false),
+ From_(nullptr), To_(nullptr), latex_(false), docbook_(false),
need_aux_(false), nice_(false), need_auth_(false)
{}
latex_flavor_ = flag_value.empty() ?
"latex" : flag_value;
} else if (flag_name == "xml")
- xml_ = true;
- else if (flag_name == "needaux")
+ docbook_ = true;
+ else if (flag_name == "needaux") {
need_aux_ = true;
- else if (flag_name == "resultdir")
+ latex_flavor_ = flag_value.empty() ?
+ "latex" : flag_value;
+ } else if (flag_name == "resultdir")
result_dir_ = (flag_value.empty())
? token_base : flag_value;
else if (flag_name == "resultfile")
nice_ = true;
else if (flag_name == "needauth")
need_auth_ = true;
+ else if (flag_name == "hyperref-driver")
+ href_driver_ = flag_value;
}
if (!result_dir_.empty() && result_file_.empty())
result_file_ = "index." + theFormats().extension(to_);
}
+void Converter::setCommand(std::string const & command)
+{
+ command_ = subst(command, token_python, os::python());
+}
+
+
Converter const * Converters::getConverter(string const & from,
string const & to) const
{
if (cit != converterlist_.end())
return &(*cit);
else
- return 0;
+ return nullptr;
}
// a list (instead of a vector), but this will cause other problems).
void Converters::update(Formats const & formats)
{
- ConverterList::iterator it = converterlist_.begin();
- ConverterList::iterator end = converterlist_.end();
- for (; it != end; ++it) {
- it->setFrom(formats.getFormat(it->from()));
- it->setTo(formats.getFormat(it->to()));
+ for (auto & cv : converterlist_) {
+ cv.setFrom(formats.getFormat(cv.from()));
+ cv.setTo(formats.getFormat(cv.to()));
}
}
}
-OutputParams::FLAVOR Converters::getFlavor(Graph::EdgePath const & path,
- Buffer const * buffer)
+Flavor Converters::getFlavor(Graph::EdgePath const & path,
+ Buffer const * buffer) const
{
- for (Graph::EdgePath::const_iterator cit = path.begin();
- cit != path.end(); ++cit) {
- Converter const & conv = converterlist_[*cit];
- if (conv.latex()) {
+ for (auto const & edge : path) {
+ Converter const & conv = converterlist_[edge];
+ if (conv.latex() || conv.need_aux()) {
if (conv.latex_flavor() == "latex")
- return OutputParams::LATEX;
+ return Flavor::LaTeX;
if (conv.latex_flavor() == "xelatex")
- return OutputParams::XETEX;
+ return Flavor::XeTeX;
if (conv.latex_flavor() == "lualatex")
- return OutputParams::LUATEX;
+ return Flavor::LuaTeX;
if (conv.latex_flavor() == "dvilualatex")
- return OutputParams::DVILUATEX;
+ return Flavor::DviLuaTeX;
if (conv.latex_flavor() == "pdflatex")
- return OutputParams::PDFLATEX;
+ return Flavor::PdfLaTeX;
}
- if (conv.xml())
- return OutputParams::XML;
+ if (conv.docbook())
+ return Flavor::DocBook5;
}
return buffer ? buffer->params().getOutputFlavor()
- : OutputParams::LATEX;
+ : Flavor::LaTeX;
+}
+
+
+string Converters::getHyperrefDriver(Graph::EdgePath const & path) const
+{
+ for (auto const & edge : path) {
+ Converter const & conv = converterlist_[edge];
+ if (!conv.hyperref_driver().empty())
+ return conv.hyperref_driver();
+ }
+ return string();
}
bool const has_shell_escape = contains(conv_command, "-shell-escape")
|| contains(conv_command, "-enable-write18");
if (conv.latex() && has_shell_escape && !use_shell_escape) {
+ // Only change font if gui is available otherwise Qt6 crashes
+ string const cmd = use_gui ? "<tt>" + conv_command + "</tt>"
+ : conv_command;
docstring const shellescape_warning =
bformat(_("<p>The following LaTeX backend has been "
"configured to allow execution of external programs "
"for any document:</p>"
- "<center><p><tt>%1$s</tt></p></center>"
+ "<center><p>%1$s</p></center>"
"<p>This is a dangerous configuration. Please, "
"consider using the support offered by LyX for "
"allowing this privilege only to documents that "
"actually need it, instead.</p>"),
- from_utf8(conv_command));
+ from_utf8(cmd));
frontend::Alert::error(_("Security Warning"),
shellescape_warning , false);
} else if (!conv.latex())
? (has_token ? conv_command.insert(token_pos, "-shell-escape ")
: conv_command.append(" -shell-escape"))
: conv_command;
+ // Only change font if gui is available otherwise Qt6 crashes
+ string const cmd = use_gui ? "<tt>" + command + "</tt>" : command;
docstring const security_warning = (use_shell_escape
? bformat(_("<p>The following LaTeX backend has been requested "
"to allow execution of external programs:</p>"
- "<center><p><tt>%1$s</tt></p></center>"
+ "<center><p>%1$s</p></center>"
"<p>The external programs can execute arbitrary commands on "
"your system, including dangerous ones, if instructed to do "
"so by a maliciously crafted LyX document.</p>"),
- from_utf8(command))
+ from_utf8(cmd))
: bformat(_("<p>The requested operation requires the use of a "
"converter from %2$s to %3$s:</p>"
- "<blockquote><p><tt>%1$s</tt></p></blockquote>"
+ "<blockquote><p>%1$s</p></blockquote>"
"<p>This external program can execute arbitrary commands on "
"your system, including dangerous ones, if instructed to do "
"so by a maliciously crafted LyX document.</p>"),
- from_utf8(command), from_utf8(conv.from()),
+ from_utf8(cmd), from_utf8(conv.from()),
from_utf8(conv.to())));
if (lyxrc.use_converter_needauth_forbidden && !use_shell_escape) {
frontend::Alert::error(
}
-bool Converters::convert(Buffer const * buffer,
+Converters::RetVal Converters::convert(Buffer const * buffer,
FileName const & from_file, FileName const & to_file,
FileName const & orig_from,
string const & from_format, string const & to_format,
- ErrorList & errorList, int conversionflags)
+ ErrorList & errorList, int conversionflags, bool includeall)
{
if (from_format == to_format)
- return move(from_format, from_file, to_file, false);
+ return move(from_format, from_file, to_file, false) ?
+ SUCCESS : FAILURE;
if ((conversionflags & try_cache) &&
ConverterCache::get().inCache(orig_from, to_format))
- return ConverterCache::get().copy(orig_from, to_format, to_file);
+ return ConverterCache::get().copy(orig_from, to_format, to_file) ?
+ SUCCESS : FAILURE;
Graph::EdgePath edgepath = getPath(from_format, to_format);
if (edgepath.empty()) {
Systemcall::Starttype starttype =
(buffer && buffer->isClone()) ?
Systemcall::WaitLoop : Systemcall::Wait;
- one.startscript(starttype, command,
- buffer ? buffer->filePath() : string(),
- buffer ? buffer->layoutPos() : string());
+ int const exitval = one.startscript(starttype, command,
+ buffer ? buffer->filePath() : string(),
+ buffer ? buffer->layoutPos() : string());
+ if (exitval == Systemcall::KILLED) {
+ frontend::Alert::warning(
+ _("Converter killed"),
+ bformat(_("The following converter was killed by the user.\n %1$s\n"),
+ from_utf8(command)));
+ return KILLED;
+ }
if (to_file.isReadableFile()) {
if (conversionflags & try_cache)
ConverterCache::get().add(orig_from,
to_format, to_file);
- return true;
+ return SUCCESS;
}
}
// only warn once per session and per file type
static std::map<string, string> warned;
if (warned.find(from_format) != warned.end() && warned.find(from_format)->second == to_format) {
- return false;
+ return FAILURE;
}
warned.insert(make_pair(from_format, to_format));
"format files to %2$s.\n"
"Define a converter in the preferences."),
from_ascii(from_format), from_ascii(to_format)));
- return false;
+ return FAILURE;
}
- // buffer is only invalid for importing, and then runparams is not
+ // buffer can only be null for importing, and then runparams is not
// used anyway.
- OutputParams runparams(buffer ? &buffer->params().encoding() : 0);
+ OutputParams runparams(buffer ? &buffer->params().encoding() : nullptr);
runparams.flavor = getFlavor(edgepath, buffer);
if (buffer) {
+ BufferParams const & bp = buffer->params();
runparams.use_japanese =
- (buffer->params().bufferFormat() == "latex"
- || suffixIs(buffer->params().bufferFormat(), "-ja"))
- && buffer->params().encoding().package() == Encoding::japanese;
- runparams.use_indices = buffer->params().use_indices;
- runparams.bibtex_command = buffer->params().bibtexCommand();
- runparams.index_command = (buffer->params().index_command == "default") ?
- string() : buffer->params().index_command;
- runparams.document_language = buffer->params().language->babel();
- runparams.only_childbibs = !buffer->params().useBiblatex()
- && !buffer->params().useBibtopic()
- && buffer->params().multibib == "child";
+ (bp.bufferFormat() == "latex"
+ || suffixIs(bp.bufferFormat(), "-ja"))
+ && bp.encoding().package() == Encoding::japanese;
+ runparams.use_indices = bp.use_indices;
+ runparams.bibtex_command = bp.bibtexCommand(true);
+ runparams.index_command = (bp.index_command == "default") ?
+ string() : bp.index_command;
+ runparams.document_language = bp.language->lang();
+ // Some macros rely on font encoding
+ runparams.main_fontenc = bp.main_font_encoding();
+ runparams.only_childbibs = !bp.useBiblatex()
+ && !bp.useBibtopic()
+ && bp.multibib == "child";
+ runparams.includeall = includeall;
}
// Some converters (e.g. lilypond) can only output files to the
string to_base = changeExtension(to_file.absFileName(), "");
FileName infile;
FileName outfile = from_file;
- for (Graph::EdgePath::const_iterator cit = edgepath.begin();
- cit != edgepath.end(); ++cit) {
- Converter const & conv = converterlist_[*cit];
+ for (auto const & edge : edgepath) {
+ Converter const & conv = converterlist_[edge];
bool dummy = conv.To()->dummy() && conv.to() != "program";
if (!dummy) {
LYXERR(Debug::FILES, "Converting from "
if (!checkAuth(conv, buffer ? buffer->absFileName() : string(),
buffer && buffer->params().shell_escape))
- return false;
+ return FAILURE;
if (conv.latex()) {
// We are not importing, we have a buffer
- LATTEST(buffer);
+ LASSERT(buffer, return FAILURE);
run_latex = true;
string command = conv.command();
command = subst(command, token_from, "");
&& !contains(command, "-shell-escape"))
command += " -shell-escape ";
LYXERR(Debug::FILES, "Running " << command);
- if (!runLaTeX(*buffer, command, runparams, errorList))
- return false;
+ // FIXME KILLED
+ // Check changed return value here.
+ RetVal const retval = runLaTeX(*buffer, command, runparams, errorList);
+ if (retval != SUCCESS)
+ return retval;
} else {
if (conv.need_aux() && !run_latex) {
// We are not importing, we have a buffer
- LATTEST(buffer);
+ LASSERT(buffer, return FAILURE);
string command;
switch (runparams.flavor) {
- case OutputParams::DVILUATEX:
+ case Flavor::DviLuaTeX:
command = dvilualatex_command_;
break;
- case OutputParams::LUATEX:
+ case Flavor::LuaTeX:
command = lualatex_command_;
break;
- case OutputParams::PDFLATEX:
+ case Flavor::PdfLaTeX:
command = pdflatex_command_;
break;
- case OutputParams::XETEX:
+ case Flavor::XeTeX:
command = xelatex_command_;
break;
default:
LYXERR(Debug::FILES, "Running "
<< command
<< " to update aux file");
- if (!runLaTeX(*buffer, command,
- runparams, errorList))
- return false;
+ // FIXME KILLED
+ // Check changed return value here.
+ RetVal const retval = runLaTeX(*buffer, command, runparams, errorList);
+ if (retval != SUCCESS)
+ return retval;
}
}
to_utf8(makeRelPath(from_utf8(outfile.absFileName()), from_utf8(path)));
string command = conv.command();
+ BufferParams const & bparams = buffer ? buffer->params() : defaultBufferParams();
command = subst(command, token_from, quoteName(infile2));
command = subst(command, token_base, quoteName(from_base));
command = subst(command, token_to, quoteName(outfile2));
command = subst(command, token_path, quoteName(onlyPath(infile.absFileName())));
command = subst(command, token_orig_path, quoteName(onlyPath(orig_from.absFileName())));
command = subst(command, token_orig_from, quoteName(onlyFileName(orig_from.absFileName())));
- command = subst(command, token_encoding, buffer ? buffer->params().encoding().iconvName() : string());
+ command = subst(command, token_textclass, quoteName(bparams.documentClass().name()));
+ string modules = bparams.getModules().asString();
+ // FIXME: remove when SystemCall uses QProcess with the list API.
+ // Currently the QProcess parser is not able to encode an
+ // empty argument as ""; work around this by passing a
+ // single comma, that will be interpreted as a list of two
+ // empty module names.
+ if (modules.empty())
+ modules = ",";
+ command = subst(command, token_modules, quoteName(modules));
+ command = subst(command, token_encoding, quoteName(bparams.encoding().iconvName()));
+ command = subst(command, token_python, os::python());
if (!conv.parselog().empty())
command += " 2> " + quoteName(infile2 + ".out");
: string(),
buffer ? buffer->layoutPos()
: string());
+ if (res == Systemcall::KILLED) {
+ frontend::Alert::warning(
+ _("Converter killed"),
+ bformat(_("The following converter was killed by the user.\n %1$s\n"),
+ from_utf8(command)));
+ return KILLED;
+ }
+
if (!real_outfile.empty()) {
Mover const & mover = getMover(conv.to());
if (!mover.rename(outfile, real_outfile))
string const command2 = conv.parselog() +
" < " + quoteName(infile2 + ".out") +
" > " + quoteName(logfile);
- one.startscript(starttype,
+ res = one.startscript(starttype,
to_filesystem8bit(from_utf8(command2)),
- buffer->filePath(),
- buffer->layoutPos());
- if (!scanLog(*buffer, command, makeAbsPath(logfile, path), errorList))
- return false;
+ buffer ? buffer->filePath() : string(),
+ buffer ? buffer->layoutPos() : string());
+ if (res == Systemcall::KILLED) {
+ frontend::Alert::warning(
+ _("Converter killed"),
+ bformat(_("The following converter was killed by the user.\n %1$s\n"),
+ from_utf8(command)));
+ return KILLED;
+ }
+ if (buffer && !scanLog(*buffer, command, makeAbsPath(logfile, path), errorList))
+ return FAILURE;
}
}
Alert::information(_("Process Killed"),
bformat(_("The conversion process was killed while running:\n%1$s"),
wrapParas(from_utf8(command))));
- } else if (res == Systemcall::TIMEOUT) {
+ return KILLED;
+ }
+ if (res == Systemcall::TIMEOUT) {
Alert::information(_("Process Timed Out"),
bformat(_("The conversion process:\n%1$s\ntimed out before completing."),
wrapParas(from_utf8(command))));
- } else if (conv.to() == "program") {
+ return KILLED;
+ }
+ if (conv.to() == "program") {
Alert::error(_("Build errors"),
_("There were errors during the build process."));
} else {
bformat(_("An error occurred while running:\n%1$s"),
wrapParas(from_utf8(command))));
}
- return false;
+ return FAILURE;
}
}
}
Converter const & conv = converterlist_[edgepath.back()];
if (conv.To()->dummy())
- return true;
+ return SUCCESS;
if (!conv.result_dir().empty()) {
// The converter has put the file(s) in a directory.
Alert::error(_("Cannot convert file"),
bformat(_("Could not move a temporary directory from %1$s to %2$s."),
from_utf8(from), from_utf8(to)));
- return false;
+ return FAILURE;
}
}
- return true;
+ return SUCCESS;
} else {
if (conversionflags & try_cache)
ConverterCache::get().add(orig_from, to_format, outfile);
- return move(conv.to(), outfile, to_file, conv.latex());
+ return move(conv.to(), outfile, to_file, conv.latex()) ? SUCCESS : FAILURE;
}
}
string const to_extension = getExtension(to.absFileName());
support::FileNameList const files = FileName(path).dirList(getExtension(from.absFileName()));
- for (support::FileNameList::const_iterator it = files.begin();
- it != files.end(); ++it) {
- string const from2 = it->absFileName();
+ for (auto const & f : files) {
+ string const from2 = f.absFileName();
string const file2 = onlyFileName(from2);
if (prefixIs(file2, base)) {
string const to2 = changeExtension(
Mover const & mover = getMover(fmt);
bool const moved = copy
- ? mover.copy(*it, FileName(to2))
- : mover.rename(*it, FileName(to2));
+ ? mover.copy(f, FileName(to2))
+ : mover.rename(f, FileName(to2));
if (!moved && no_errors) {
Alert::error(_("Cannot convert file"),
bformat(copy ?
}
-bool Converters::formatIsUsed(string const & format)
+bool Converters::formatIsUsed(string const & format) const
{
- ConverterList::const_iterator cit = converterlist_.begin();
- ConverterList::const_iterator end = converterlist_.end();
- for (; cit != end; ++cit) {
- if (cit->from() == format || cit->to() == format)
+ for (auto const & cvt : converterlist_) {
+ if (cvt.from() == format || cvt.to() == format)
return true;
}
return false;
bool Converters::scanLog(Buffer const & buffer, string const & /*command*/,
FileName const & filename, ErrorList & errorList)
{
- OutputParams runparams(0);
- runparams.flavor = OutputParams::LATEX;
+ OutputParams runparams(nullptr);
+ runparams.flavor = Flavor::LaTeX;
LaTeX latex("", runparams, filename);
TeXErrors terr;
int const result = latex.scanLogFile(terr);
}
-bool Converters::runLaTeX(Buffer const & buffer, string const & command,
+Converters::RetVal Converters::runLaTeX(Buffer const & buffer, string const & command,
OutputParams const & runparams, ErrorList & errorList)
{
buffer.setBusy(true);
// do the LaTeX run(s)
string const name = buffer.latexName();
- LaTeX latex(command, runparams, FileName(makeAbsPath(name)),
+ LaTeX latex(command, runparams, makeAbsPath(name),
buffer.filePath(), buffer.layoutPos(),
- buffer.isClone(), buffer.lastPreviewError());
+ buffer.isClone(), buffer.freshStartRequired());
TeXErrors terr;
// The connection closes itself at the end of the scope when latex is
// destroyed. One cannot close (and destroy) buffer while the converter is
});
int const result = latex.run(terr);
- if (result == Systemcall::KILLED) {
+ if (result == Systemcall::KILLED || result == Systemcall::TIMEOUT) {
Alert::error(_("Export canceled"),
_("The export process was terminated by the user."));
- return result;
+ return KILLED;
}
if (result & LaTeX::ERRORS)
buffer.bufferErrors(terr, errorList);
+ if ((result & LaTeX::UNDEF_CIT) || (result & LaTeX::UNDEF_UNKNOWN_REF)) {
+ buffer.bufferRefs(terr, errorList);
+ if (errorList.empty())
+ errorList.push_back(ErrorItem(_("Undefined reference"),
+ _("Undefined references or citations were found during the build.\n"
+ "Please check the warnings in the LaTeX log (Document > LaTeX Log)."),
+ &buffer));
+ }
+
if (!errorList.empty()) {
// We will show the LaTeX Errors GUI later which contains
// specific error messages so it would be repetitive to give
_("No output file was generated."));
}
-
buffer.setBusy(false);
int const ERROR_MASK =
LaTeX::NO_LOGFILE |
LaTeX::ERRORS |
+ LaTeX::UNDEF_CIT |
+ LaTeX::UNDEF_UNKNOWN_REF |
LaTeX::NO_OUTPUT;
- return (result & ERROR_MASK) == 0;
+ return (result & ERROR_MASK) == 0 ? SUCCESS : FAILURE;
}
// each of the converters knows how to convert one format to another
// so, for each of them, we create an arrow on the graph, going from
// the one to the other
- ConverterList::iterator it = converterlist_.begin();
- ConverterList::iterator const end = converterlist_.end();
- for (; it != end ; ++it) {
- int const from = theFormats().getNumber(it->from());
- int const to = theFormats().getNumber(it->to());
+ for (auto const & cvt : converterlist_) {
+ int const from = theFormats().getNumber(cvt.from());
+ int const to = theFormats().getNumber(cvt.to());
LASSERT(from >= 0, continue);
LASSERT(to >= 0, continue);
G_.addEdge(from, to);
{
set<int> excluded_numbers;
- set<string>::const_iterator sit = excludes.begin();
- set<string>::const_iterator const end = excludes.end();
- for (; sit != end; ++sit)
- excluded_numbers.insert(theFormats().getNumber(*sit));
+ for (auto const & ex : excludes)
+ excluded_numbers.insert(theFormats().getNumber(ex));
vector<int> const & reachables =
G_.getReachable(theFormats().getNumber(from),
projects / lyx.git / blobdiff