src/LaTeX.h

   1 // -*- C++ -*-
   2 /**
   3  * \file LaTeX.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author Lars Gullik Bjønnes
   8  * \author Angus Leeming
   9  * \author Dekel Tsur
  10  *
  11  * Full author contact details are available in file CREDITS.
  12  */
  13
  14 #ifndef LATEX_H
  15 #define LATEX_H
  16
  17 #include "OutputParams.h"
  18
  19 #include "support/docstring.h"
  20 #include "support/FileName.h"
  21 #include "support/signals.h"
  22
  23 #include <vector>
  24 #include <set>
  25
  26
  27 namespace lyx {
  28
  29 class DepTable;
  30
  31 ///
  32 class TeXErrors {
  33 private:
  34         ///
  35         class Error {
  36         public:
  37                 ///
  38                 Error () : error_in_line(0) {}
  39                 ///
  40                 Error(int line, docstring const & desc, docstring const & text,
  41                       std::string const & fname)
  42                         : error_in_line(line),
  43                           error_desc(desc),
  44                           error_text(text),
  45                           child_name(fname) {}
  46                 /// what line in the TeX file the error occurred in
  47                 int error_in_line;
  48                 /// The kind of error
  49                 docstring error_desc;
  50                 /// The line/cmd that caused the error.
  51                 docstring error_text;
  52                 /// The name of the child where error occurred, empty otherwise.
  53                 std::string child_name;
  54         };
  55 public:
  56         ///
  57         typedef std::vector<Error> Errors;
  58         ///
  59         Errors::const_iterator begin() const { return errors.begin(); }
  60         ///
  61         Errors::const_iterator end() const { return errors.end(); }
  62         ///
  63         void insertError(int line, docstring const & error_desc,
  64                          docstring const & error_text,
  65                          std::string const & child_name = empty_string());
  66         ///
  67         void clearErrors() { errors.clear(); }
  68 private:
  69         ///
  70         Errors errors;
  71 };
  72
  73
  74 class AuxInfo {
  75 public:
  76         ///
  77         AuxInfo() {}
  78         ///
  79         support::FileName aux_file;
  80         ///
  81         std::set<std::string> citations;
  82         ///
  83         std::set<std::string> databases;
  84         ///
  85         std::set<std::string> styles;
  86 };
  87
  88
  89 ///
  90 bool operator==(AuxInfo const &, AuxInfo const &);
  91 bool operator!=(AuxInfo const &, AuxInfo const &);
  92
  93
  94 /**
  95  * Class to run the LaTeX compiler and needed auxiliary programs.
  96  * The main .tex file must be in the current directory. The current directory
  97  * must not change as long as an object of this class lives.
  98  * This is required by the LaTeX compiler, and we also make use of it by
  99  * various support::makeAbsPath() calls.
 100  */
 101 class LaTeX {
 102 public:
 103         /** Return values from scanLogFile() and run() (to come)
 104
 105             This enum should be enlarged a bit so that one could
 106             get more feedback from the LaTeX run.
 107         */
 108         enum log_status {
 109                 ///
 110                 NO_ERRORS = 0,
 111                 ///
 112                 NO_LOGFILE = 1,
 113                 ///
 114                 NO_OUTPUT = 2,
 115                 ///
 116                 UNDEF_REF = 4, // Reference '...' on page ... undefined.
 117                 ///
 118                 UNDEF_CIT = 8, // Citation '...' on page ... undefined.
 119                 ///
 120                 RERUN = 16, // Label(s) may have changed. Rerun to get...
 121                 ///
 122                 TEX_ERROR = 32,
 123                 ///
 124                 TEX_WARNING = 64,
 125                 ///
 126                 LATEX_ERROR = 128,
 127                 ///
 128                 LATEX_WARNING = 256,
 129                 ///
 130                 PACKAGE_WARNING = 512,
 131                 ///
 132                 NO_FILE = 1024,
 133                 ///
 134                 NO_CHANGE = 2048,
 135                 ///
 136                 TOO_MANY_ERRORS = 4096,
 137                 ///
 138                 ERROR_RERUN = 8192,
 139                 ///
 140                 BIBTEX_ERROR = 16384,
 141                 ///
 142                 NONZERO_ERROR = 32768, // the command exited with nonzero status
 143                 ///
 144                 ERRORS = TEX_ERROR + LATEX_ERROR + NONZERO_ERROR + BIBTEX_ERROR,
 145                 ///
 146                 WARNINGS = TEX_WARNING + LATEX_WARNING + PACKAGE_WARNING
 147         };
 148
 149         /// This signal emits an informative message
 150         signals2::signal<void(docstring)> message;
 151
 152
 153         /**
 154            cmd = the latex command, file = name of the (temporary) latex file,
 155            path = name of the files original path,
 156            clean_start = This forces a fresh run by deleting the files in the temp
 157                          dir. We set this e.g. if there was an error on previous
 158                          preview, which is good if the user installed a package
 159                          or changed certain document settings (#9061).
 160         */
 161         LaTeX(std::string const & cmd, OutputParams const &,
 162               support::FileName const & file,
 163               std::string const & path = empty_string(),
 164               std::string const & lpath = empty_string(),
 165               bool const clean_start = false);
 166
 167         /// runs LaTeX several times
 168         int run(TeXErrors &);
 169
 170         ///
 171         int getNumErrors() { return num_errors;}
 172
 173         ///
 174         int scanLogFile(TeXErrors &);
 175
 176 private:
 177         /// noncopyable
 178         LaTeX(LaTeX const &);
 179         void operator=(LaTeX const &);
 180
 181         /// use this for running LaTeX once
 182         int startscript();
 183
 184         /// The dependency file.
 185         support::FileName depfile;
 186
 187         ///
 188         void deplog(DepTable & head);
 189
 190         ///
 191         bool runMakeIndex(std::string const &, OutputParams const &,
 192                           std::string const & = std::string());
 193
 194         ///
 195         bool runMakeIndexNomencl(support::FileName const &,
 196                                  std::string const &, std::string const &);
 197
 198         ///
 199         std::vector<AuxInfo> const scanAuxFiles(support::FileName const &,
 200                                                 bool const only_childbibs = false);
 201
 202         ///
 203         AuxInfo const scanAuxFile(support::FileName const &);
 204
 205         ///
 206         void scanAuxFile(support::FileName const &, AuxInfo &);
 207
 208         ///
 209         void updateBibtexDependencies(DepTable &,
 210                                       std::vector<AuxInfo> const &);
 211
 212         ///
 213         int scanBlgFile(DepTable & head, TeXErrors & terr);
 214
 215         ///
 216         bool runBibTeX(std::vector<AuxInfo> const &,
 217                        OutputParams const &);
 218
 219         ///
 220         void removeAuxiliaryFiles() const;
 221
 222         ///
 223         std::string cmd;
 224
 225         ///
 226         support::FileName file;
 227
 228         /// The document directory path.
 229         std::string path;
 230
 231         /// Extra path, possibly relative to the document directory path.
 232         std::string lpath;
 233
 234         /// used by scanLogFile
 235         int num_errors;
 236
 237         /// The name of the final output file.
 238         support::FileName output_file;
 239
 240         ///
 241         OutputParams runparams;
 242
 243         /// Do we use biber?
 244         bool biber;
 245
 246         ///
 247         std::vector <std::string> children;
 248 };
 249
 250
 251 } // namespace lyx
 252
 253 #endif