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