]> git.lyx.org Git - lyx.git/blob - src/Converter.cpp
Fixed some lines that were too long. It compiled afterwards.
[lyx.git] / src / Converter.cpp
1 /**
2  * \file Converter.cpp
3  * This file is part of LyX, the document processor.
4  * Licence details can be found in the file COPYING.
5  *
6  * \author Dekel Tsur
7  *
8  * Full author contact details are available in file CREDITS.
9  */
10
11 #include <config.h>
12
13 #include "Converter.h"
14
15 #include "ConverterCache.h"
16 #include "Buffer.h"
17 #include "buffer_funcs.h"
18 #include "BufferParams.h"
19 #include "debug.h"
20 #include "ErrorList.h"
21 #include "Format.h"
22 #include "gettext.h"
23 #include "Language.h"
24 #include "LaTeX.h"
25 #include "Mover.h"
26
27 #include "frontends/alert.h"
28
29 #include "support/filetools.h"
30 #include "support/lyxlib.h"
31 #include "support/os.h"
32 #include "support/Package.h"
33 #include "support/Path.h"
34 #include "support/Systemcall.h"
35
36 using std::endl;
37 using std::find_if;
38 using std::string;
39 using std::vector;
40 using std::distance;
41
42
43 namespace lyx {
44
45 using support::addName;
46 using support::bformat;
47 using support::changeExtension;
48 using support::compare_ascii_no_case;
49 using support::contains;
50 using support::dirList;
51 using support::FileName;
52 using support::getExtension;
53 using support::isFileReadable;
54 using support::libFileSearch;
55 using support::libScriptSearch;
56 using support::makeAbsPath;
57 using support::makeRelPath;
58 using support::onlyFilename;
59 using support::onlyPath;
60 using support::package;
61 using support::prefixIs;
62 using support::quoteName;
63 using support::removeExtension;
64 using support::split;
65 using support::subst;
66 using support::Systemcall;
67
68 namespace Alert = lyx::frontend::Alert;
69
70
71 namespace {
72
73 string const token_from("$$i");
74 string const token_base("$$b");
75 string const token_to("$$o");
76 string const token_path("$$p");
77
78
79
80 string const add_options(string const & command, string const & options)
81 {
82         string head;
83         string const tail = split(command, head, ' ');
84         return head + ' ' + options + ' ' + tail;
85 }
86
87
88 string const dvipdfm_options(BufferParams const & bp)
89 {
90         string result;
91
92         if (bp.papersize != PAPER_CUSTOM) {
93                 string const paper_size = bp.paperSizeName();
94                 if (paper_size != "b5" && paper_size != "foolscap")
95                         result = "-p "+ paper_size;
96
97                 if (bp.orientation == ORIENTATION_LANDSCAPE)
98                         result += " -l";
99         }
100
101         return result;
102 }
103
104
105 class ConverterEqual : public std::binary_function<string, string, bool> {
106 public:
107         ConverterEqual(string const & from, string const & to)
108                 : from_(from), to_(to) {}
109         bool operator()(Converter const & c) const {
110                 return c.from == from_ && c.to == to_;
111         }
112 private:
113         string const from_;
114         string const to_;
115 };
116
117 } // namespace anon
118
119
120 Converter::Converter(string const & f, string const & t,
121                      string const & c, string const & l)
122         : from(f), to(t), command(c), flags(l),
123           From(0), To(0), latex(false), xml(false),
124           need_aux(false)
125 {}
126
127
128 void Converter::readFlags()
129 {
130         string flag_list(flags);
131         while (!flag_list.empty()) {
132                 string flag_name, flag_value;
133                 flag_list = split(flag_list, flag_value, ',');
134                 flag_value = split(flag_value, flag_name, '=');
135                 if (flag_name == "latex")
136                         latex = true;
137                 else if (flag_name == "xml")
138                         xml = true;
139                 else if (flag_name == "needaux")
140                         need_aux = true;
141                 else if (flag_name == "resultdir")
142                         result_dir = (flag_value.empty())
143                                 ? token_base : flag_value;
144                 else if (flag_name == "resultfile")
145                         result_file = flag_value;
146                 else if (flag_name == "parselog")
147                         parselog = flag_value;
148         }
149         if (!result_dir.empty() && result_file.empty())
150                 result_file = "index." + formats.extension(to);
151         //if (!contains(command, token_from))
152         //      latex = true;
153 }
154
155
156 bool operator<(Converter const & a, Converter const & b)
157 {
158         // use the compare_ascii_no_case instead of compare_no_case,
159         // because in turkish, 'i' is not the lowercase version of 'I',
160         // and thus turkish locale breaks parsing of tags.
161         int const i = compare_ascii_no_case(a.From->prettyname(),
162                                             b.From->prettyname());
163         if (i == 0)
164                 return compare_ascii_no_case(a.To->prettyname(),
165                                              b.To->prettyname()) < 0;
166         else
167                 return i < 0;
168 }
169
170
171 Converter const * Converters::getConverter(string const & from,
172                                             string const & to) const
173 {
174         ConverterList::const_iterator const cit =
175                 find_if(converterlist_.begin(), converterlist_.end(),
176                         ConverterEqual(from, to));
177         if (cit != converterlist_.end())
178                 return &(*cit);
179         else
180                 return 0;
181 }
182
183
184 int Converters::getNumber(string const & from, string const & to) const
185 {
186         ConverterList::const_iterator const cit =
187                 find_if(converterlist_.begin(), converterlist_.end(),
188                         ConverterEqual(from, to));
189         if (cit != converterlist_.end())
190                 return distance(converterlist_.begin(), cit);
191         else
192                 return -1;
193 }
194
195
196 void Converters::add(string const & from, string const & to,
197                      string const & command, string const & flags)
198 {
199         formats.add(from);
200         formats.add(to);
201         ConverterList::iterator it = find_if(converterlist_.begin(),
202                                              converterlist_.end(),
203                                              ConverterEqual(from , to));
204
205         Converter converter(from, to, command, flags);
206         if (it != converterlist_.end() && !flags.empty() && flags[0] == '*') {
207                 converter = *it;
208                 converter.command = command;
209                 converter.flags = flags;
210         }
211         converter.readFlags();
212
213         if (converter.latex && (latex_command_.empty() || to == "dvi"))
214                 latex_command_ = subst(command, token_from, "");
215         // If we have both latex & pdflatex, we set latex_command to latex.
216         // The latex_command is used to update the .aux file when running
217         // a converter that uses it.
218
219         if (it == converterlist_.end()) {
220                 converterlist_.push_back(converter);
221         } else {
222                 converter.From = it->From;
223                 converter.To = it->To;
224                 *it = converter;
225         }
226 }
227
228
229 void Converters::erase(string const & from, string const & to)
230 {
231         ConverterList::iterator const it =
232                 find_if(converterlist_.begin(),
233                         converterlist_.end(),
234                         ConverterEqual(from, to));
235         if (it != converterlist_.end())
236                 converterlist_.erase(it);
237 }
238
239
240 // This method updates the pointers From and To in all the converters.
241 // The code is not very efficient, but it doesn't matter as the number
242 // of formats and converters is small.
243 // Furthermore, this method is called only on startup, or after
244 // adding/deleting a format in FormPreferences (the latter calls can be
245 // eliminated if the formats in the Formats class are stored using a map or
246 // a list (instead of a vector), but this will cause other problems).
247 void Converters::update(Formats const & formats)
248 {
249         ConverterList::iterator it = converterlist_.begin();
250         ConverterList::iterator end = converterlist_.end();
251         for (; it != end; ++it) {
252                 it->From = formats.getFormat(it->from);
253                 it->To = formats.getFormat(it->to);
254         }
255 }
256
257
258 // This method updates the pointers From and To in the last converter.
259 // It is called when adding a new converter in FormPreferences
260 void Converters::updateLast(Formats const & formats)
261 {
262         if (converterlist_.begin() != converterlist_.end()) {
263                 ConverterList::iterator it = converterlist_.end() - 1;
264                 it->From = formats.getFormat(it->from);
265                 it->To = formats.getFormat(it->to);
266         }
267 }
268
269
270 void Converters::sort()
271 {
272         std::sort(converterlist_.begin(), converterlist_.end());
273 }
274
275
276 OutputParams::FLAVOR Converters::getFlavor(Graph::EdgePath const & path)
277 {
278         for (Graph::EdgePath::const_iterator cit = path.begin();
279              cit != path.end(); ++cit) {
280                 Converter const & conv = converterlist_[*cit];
281                 if (conv.latex)
282                         if (contains(conv.to, "pdf"))
283                                 return OutputParams::PDFLATEX;
284                 if (conv.xml)
285                         return OutputParams::XML;
286         }
287         return OutputParams::LATEX;
288 }
289
290
291 bool Converters::convert(Buffer const * buffer,
292                          FileName const & from_file, FileName const & to_file,
293                          FileName const & orig_from,
294                          string const & from_format, string const & to_format,
295                          ErrorList & errorList, int conversionflags)
296 {
297         if (from_format == to_format)
298                 return move(from_format, from_file, to_file, false);
299
300         if ((conversionflags & try_cache) &&
301             ConverterCache::get().inCache(orig_from, to_format))
302                 return ConverterCache::get().copy(orig_from, to_format, to_file);
303
304         Graph::EdgePath edgepath = getPath(from_format, to_format);
305         if (edgepath.empty()) {
306                 if (conversionflags & try_default) {
307                         // if no special converter defined, then we take the
308                         // default one from ImageMagic.
309                         string const from_ext = from_format.empty() ?
310                                 getExtension(from_file.absFilename()) :
311                                 formats.extension(from_format);
312                         string const to_ext = formats.extension(to_format);
313                         string const command =
314                                 support::os::python() + ' ' +
315                                 quoteName(libFileSearch("scripts", "convertDefault.py").toFilesystemEncoding()) +
316                                 ' ' +
317                                 quoteName(from_ext + ':' + from_file.toFilesystemEncoding()) +
318                                 ' ' +
319                                 quoteName(to_ext + ':' + to_file.toFilesystemEncoding());
320                         LYXERR(Debug::FILES)
321                                 << "No converter defined! "
322                                    "I use convertDefault.py:\n\t"
323                                 << command << endl;
324                         Systemcall one;
325                         one.startscript(Systemcall::Wait, command);
326                         if (isFileReadable(to_file)) {
327                                 if (conversionflags & try_cache)
328                                         ConverterCache::get().add(orig_from,
329                                                         to_format, to_file);
330                                 return true;
331                         }
332                 }
333                 Alert::error(_("Cannot convert file"),
334                              bformat(_("No information for converting %1$s "
335                                                     "format files to %2$s.\n"
336                                                     "Define a converter in the preferences."),
337                                                         from_ascii(from_format), from_ascii(to_format)));
338                 return false;
339         }
340
341         // buffer is only invalid for importing, and then runparams is not
342         // used anyway.
343         OutputParams runparams(buffer ? &buffer->params().encoding() : 0);
344         runparams.flavor = getFlavor(edgepath);
345
346         // Some converters (e.g. lilypond) can only output files to the
347         // current directory, so we need to change the current directory.
348         // This has the added benefit that all other files that may be
349         // generated by the converter are deleted when LyX closes and do not
350         // clutter the real working directory.
351         string const path(onlyPath(from_file.absFilename()));
352         // Prevent the compiler from optimizing away p
353         FileName pp(path);
354         support::Path p(pp);
355
356         // empty the error list before any new conversion takes place.
357         errorList.clear();
358
359         bool run_latex = false;
360         string from_base = changeExtension(from_file.absFilename(), "");
361         string to_base = changeExtension(to_file.absFilename(), "");
362         FileName infile;
363         FileName outfile = from_file;
364         for (Graph::EdgePath::const_iterator cit = edgepath.begin();
365              cit != edgepath.end(); ++cit) {
366                 Converter const & conv = converterlist_[*cit];
367                 bool dummy = conv.To->dummy() && conv.to != "program";
368                 if (!dummy)
369                         LYXERR(Debug::FILES) << "Converting from  "
370                                << conv.from << " to " << conv.to << endl;
371                 infile = outfile;
372                 outfile = FileName(conv.result_dir.empty()
373                         ? changeExtension(from_file.absFilename(), conv.To->extension())
374                         : addName(subst(conv.result_dir,
375                                         token_base, from_base),
376                                   subst(conv.result_file,
377                                         token_base, onlyFilename(from_base))));
378
379                 // if input and output files are equal, we use a
380                 // temporary file as intermediary (JMarc)
381                 FileName real_outfile;
382                 if (outfile == infile) {
383                         real_outfile = infile;
384                         // when importing, a buffer does not necessarily exist
385                         if (buffer)
386                                 outfile = FileName(addName(buffer->temppath(), "tmpfile.out"));
387                         else
388                                 outfile = FileName(addName(package().temp_dir().absFilename(),
389                                                    "tmpfile.out"));
390                 }
391
392                 if (conv.latex) {
393                         run_latex = true;
394                         string const command = subst(conv.command, token_from, "");
395                         LYXERR(Debug::FILES) << "Running " << command << endl;
396                         if (!runLaTeX(*buffer, command, runparams, errorList))
397                                 return false;
398                 } else {
399                         if (conv.need_aux && !run_latex
400                             && !latex_command_.empty()) {
401                                 LYXERR(Debug::FILES)
402                                         << "Running " << latex_command_
403                                         << " to update aux file"<<  endl;
404                                 runLaTeX(*buffer, latex_command_, runparams, errorList);
405                         }
406
407                         // FIXME UNICODE
408                         string const infile2 = 
409                                 to_utf8(makeRelPath(from_utf8(infile.absFilename()), from_utf8(path)));
410                         string const outfile2 = 
411                                 to_utf8(makeRelPath(from_utf8(outfile.absFilename()), from_utf8(path)));
412
413                         string command = conv.command;
414                         command = subst(command, token_from, quoteName(infile2));
415                         command = subst(command, token_base, quoteName(from_base));
416                         command = subst(command, token_to, quoteName(outfile2));
417                         command = libScriptSearch(command);
418
419                         if (!conv.parselog.empty())
420                                 command += " 2> " + quoteName(infile2 + ".out");
421
422                         if (conv.from == "dvi" && conv.to == "ps")
423                                 command = add_options(command,
424                                                       buffer->params().dvips_options());
425                         else if (conv.from == "dvi" && prefixIs(conv.to, "pdf"))
426                                 command = add_options(command,
427                                                       dvipdfm_options(buffer->params()));
428
429                         LYXERR(Debug::FILES) << "Calling " << command << endl;
430                         if (buffer)
431                                 buffer->message(_("Executing command: ")
432                                 + from_utf8(command));
433
434                         Systemcall one;
435                         int res;
436                         if (dummy) {
437                                 res = one.startscript(Systemcall::DontWait,
438                                         to_filesystem8bit(from_utf8(command)));
439                                 // We're not waiting for the result, so we can't do anything
440                                 // else here.
441                         } else {
442                                 res = one.startscript(Systemcall::Wait,
443                                                 to_filesystem8bit(from_utf8(command)));
444                                 if (!real_outfile.empty()) {
445                                         Mover const & mover = getMover(conv.to);
446                                         if (!mover.rename(outfile, real_outfile))
447                                                 res = -1;
448                                         else
449                                                 LYXERR(Debug::FILES)
450                                                         << "renaming file " << outfile
451                                                         << " to " << real_outfile
452                                                         << endl;
453                                         // Finally, don't forget to tell any future
454                                         // converters to use the renamed file...
455                                         outfile = real_outfile;
456                                 }
457   
458                                 if (!conv.parselog.empty()) {
459                                         string const logfile =  infile2 + ".log";
460                                         string const script = libScriptSearch(conv.parselog);
461                                         string const command2 = script +
462                                                 " < " + quoteName(infile2 + ".out") +
463                                                 " > " + quoteName(logfile);
464                                         one.startscript(Systemcall::Wait,
465                                                 to_filesystem8bit(from_utf8(command2)));
466                                         if (!scanLog(*buffer, command, makeAbsPath(logfile, path), errorList))
467                                                 return false;
468                                 }
469                         }
470
471                         if (res) {
472                                 if (conv.to == "program") {
473                                         Alert::error(_("Build errors"),
474                                                 _("There were errors during the build process."));
475                                 } else {
476 // FIXME: this should go out of here. For example, here we cannot say if
477 // it is a document (.lyx) or something else. Same goes for elsewhere.
478                                         Alert::error(_("Cannot convert file"),
479                                                 bformat(_("An error occurred whilst running %1$s"),
480                                                 from_utf8(command.substr(0, 50))));
481                                 }
482                                 return false;
483                         }
484                 }
485         }
486
487         Converter const & conv = converterlist_[edgepath.back()];
488         if (conv.To->dummy())
489                 return true;
490
491         if (!conv.result_dir.empty()) {
492                 // The converter has put the file(s) in a directory.
493                 // In this case we ignore the given to_file.
494                 if (from_base != to_base) {
495                         string const from = subst(conv.result_dir,
496                                             token_base, from_base);
497                         string const to = subst(conv.result_dir,
498                                           token_base, to_base);
499                         Mover const & mover = getMover(conv.from);
500                         if (!mover.rename(FileName(from), FileName(to))) {
501                                 Alert::error(_("Cannot convert file"),
502                                         bformat(_("Could not move a temporary directory from %1$s to %2$s."),
503                                                 from_utf8(from), from_utf8(to)));
504                                 return false;
505                         }
506                 }
507                 return true;
508         } else {
509                 if (conversionflags & try_cache)
510                         ConverterCache::get().add(orig_from, to_format, outfile);
511                 return move(conv.to, outfile, to_file, conv.latex);
512         }
513 }
514
515
516 bool Converters::move(string const & fmt,
517                       FileName const & from, FileName const & to, bool copy)
518 {
519         if (from == to)
520                 return true;
521
522         bool no_errors = true;
523         string const path = onlyPath(from.absFilename());
524         string const base = onlyFilename(removeExtension(from.absFilename()));
525         string const to_base = removeExtension(to.absFilename());
526         string const to_extension = getExtension(to.absFilename());
527
528         vector<FileName> const files = dirList(FileName(path),
529                         getExtension(from.absFilename()));
530         for (vector<FileName>::const_iterator it = files.begin();
531              it != files.end(); ++it) {
532                 string const from2 = it->absFilename();
533                 string const file2 = onlyFilename(from2);
534                 if (prefixIs(file2, base)) {
535                         string const to2 = changeExtension(
536                                 to_base + file2.substr(base.length()),
537                                 to_extension);
538                         LYXERR(Debug::FILES) << "moving " << from2
539                                              << " to " << to2 << endl;
540
541                         Mover const & mover = getMover(fmt);
542                         bool const moved = copy
543                                 ? mover.copy(*it, FileName(to2))
544                                 : mover.rename(*it, FileName(to2));
545                         if (!moved && no_errors) {
546                                 Alert::error(_("Cannot convert file"),
547                                         bformat(copy ?
548                                                 _("Could not copy a temporary file from %1$s to %2$s.") :
549                                                 _("Could not move a temporary file from %1$s to %2$s."),
550                                                 from_utf8(from2), from_utf8(to2)));
551                                 no_errors = false;
552                         }
553                 }
554         }
555         return no_errors;
556 }
557
558
559 bool Converters::formatIsUsed(string const & format)
560 {
561         ConverterList::const_iterator cit = converterlist_.begin();
562         ConverterList::const_iterator end = converterlist_.end();
563         for (; cit != end; ++cit) {
564                 if (cit->from == format || cit->to == format)
565                         return true;
566         }
567         return false;
568 }
569
570
571 bool Converters::scanLog(Buffer const & buffer, string const & /*command*/,
572                          FileName const & filename, ErrorList & errorList)
573 {
574         OutputParams runparams(0);
575         runparams.flavor = OutputParams::LATEX;
576         LaTeX latex("", runparams, filename);
577         TeXErrors terr;
578         int const result = latex.scanLogFile(terr);
579
580         if (result & LaTeX::ERRORS)
581                 bufferErrors(buffer, terr, errorList);
582
583         return true;
584 }
585
586
587 namespace {
588
589 class showMessage : public std::unary_function<docstring, void>, public boost::signals::trackable {
590 public:
591         showMessage(Buffer const & b) : buffer_(b) {};
592         void operator()(docstring const & m) const
593         {
594                 buffer_.message(m);
595         }
596 private:
597         Buffer const & buffer_;
598 };
599
600 }
601
602
603 bool Converters::runLaTeX(Buffer const & buffer, string const & command,
604                           OutputParams const & runparams, ErrorList & errorList)
605 {
606         buffer.busy(true);
607         buffer.message(_("Running LaTeX..."));
608
609         runparams.document_language = buffer.params().language->babel();
610
611         // do the LaTeX run(s)
612         string const name = buffer.getLatexName();
613         LaTeX latex(command, runparams, FileName(makeAbsPath(name)));
614         TeXErrors terr;
615         showMessage show(buffer);
616         latex.message.connect(show);
617         int const result = latex.run(terr);
618
619         if (result & LaTeX::ERRORS)
620                 bufferErrors(buffer, terr, errorList);
621
622         // check return value from latex.run().
623         if ((result & LaTeX::NO_LOGFILE)) {
624                 docstring const str =
625                         bformat(_("LaTeX did not run successfully. "
626                                                "Additionally, LyX could not locate "
627                                                "the LaTeX log %1$s."), from_utf8(name));
628                 Alert::error(_("LaTeX failed"), str);
629         } else if (result & LaTeX::NO_OUTPUT) {
630                 Alert::warning(_("Output is empty"),
631                                _("An empty output file was generated."));
632         }
633
634
635         buffer.busy(false);
636
637         int const ERROR_MASK =
638                         LaTeX::NO_LOGFILE |
639                         LaTeX::ERRORS |
640                         LaTeX::NO_OUTPUT;
641
642         return (result & ERROR_MASK) == 0;
643
644 }
645
646
647
648 void Converters::buildGraph()
649 {
650         G_.init(formats.size());
651         ConverterList::iterator beg = converterlist_.begin();
652         ConverterList::iterator const end = converterlist_.end();
653         for (ConverterList::iterator it = beg; it != end ; ++it) {
654                 int const s = formats.getNumber(it->from);
655                 int const t = formats.getNumber(it->to);
656                 G_.addEdge(s,t);
657         }
658 }
659
660
661 std::vector<Format const *> const
662 Converters::intToFormat(std::vector<int> const & input)
663 {
664         vector<Format const *> result(input.size());
665
666         vector<int>::const_iterator it = input.begin();
667         vector<int>::const_iterator const end = input.end();
668         vector<Format const *>::iterator rit = result.begin();
669         for ( ; it != end; ++it, ++rit) {
670                 *rit = &formats.get(*it);
671         }
672         return result;
673 }
674
675
676 vector<Format const *> const
677 Converters::getReachableTo(string const & target, bool const clear_visited)
678 {
679         vector<int> const & reachablesto =
680                 G_.getReachableTo(formats.getNumber(target), clear_visited);
681
682         return intToFormat(reachablesto);
683 }
684
685
686 vector<Format const *> const
687 Converters::getReachable(string const & from, bool const only_viewable,
688                          bool const clear_visited)
689 {
690         vector<int> const & reachables =
691                 G_.getReachable(formats.getNumber(from),
692                                 only_viewable,
693                                 clear_visited);
694
695         return intToFormat(reachables);
696 }
697
698
699 bool Converters::isReachable(string const & from, string const & to)
700 {
701         return G_.isReachable(formats.getNumber(from),
702                               formats.getNumber(to));
703 }
704
705
706 Graph::EdgePath const
707 Converters::getPath(string const & from, string const & to)
708 {
709         return G_.getPath(formats.getNumber(from),
710                           formats.getNumber(to));
711 }
712
713 } // namespace lyx