X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FLaTeX.C;h=53cf4e9241b19993ac8c5b8257ca291aaf4f16fa;hb=a9713c5563c924f4ab98bde3d9f24a5c1e4dd50e;hp=a4999fa2707b52ead0f720cd6da8b5d3cf236e88;hpb=d7dbc63467b8ddc07aaca9fa3c73b2b2325a9c5f;p=lyx.git diff --git a/src/LaTeX.C b/src/LaTeX.C index a4999fa270..53cf4e9241 100644 --- a/src/LaTeX.C +++ b/src/LaTeX.C @@ -1,11 +1,11 @@ /* This file is part of * ====================================================== - * - * LyX, The Document Processor + * + * LyX, The Document Processor * Copyright 1995 Matthias Ettrich - * Copyright 1995-1999 The LyX Team. + * Copyright 1995-2001 The LyX Team. * - * This file is Copyright 1996-1999 + * This file is Copyright 1996-2001 * Lars Gullik Bjønnes * * ====================================================== @@ -13,251 +13,161 @@ #include -#include -#include - -#ifdef __GNUG__ -#pragma implementation -#endif - -#include "support/filetools.h" #include "LaTeX.h" -#include "lyxlex.h" -#include "support/FileInfo.h" -#include "debug.h" -#include "support/lyxlib.h" -#include "support/syscall.h" -#include "support/syscontr.h" -#include "pathstack.h" #include "bufferlist.h" -#include "minibuffer.h" #include "gettext.h" +#include "lyxfunc.h" +#include "debug.h" +#include "funcrequest.h" +#include "support/filetools.h" +#include "support/FileInfo.h" +#include "support/tostr.h" +#include "support/lstrings.h" +#include "support/lyxlib.h" +#include "support/systemcall.h" +#include "support/os.h" +#include "support/path.h" -extern BufferList bufferlist; +#include -struct texfile_struct { - LaTeX::TEX_FILES file; - char const *extension; -}; +#include +#include // sscanf -static -const texfile_struct all_files[] = { - { LaTeX::AUX, ".aux"}, - { LaTeX::BBL, ".bbl"}, - { LaTeX::DVI, ".dvi"}, - { LaTeX::GLO, ".glo"}, - { LaTeX::IDX, ".idx"}, - { LaTeX::IND, ".ind"}, - { LaTeX::LOF, ".lof"}, - { LaTeX::LOA, ".loa"}, - { LaTeX::LOG, ".log"}, - { LaTeX::LOT, ".lot"}, - { LaTeX::TOC, ".toc"}, - { LaTeX::LTX, ".ltx"}, - { LaTeX::TEX, ".tex"} -}; +#ifndef CXX_GLOBAL_CSTD +using std::sscanf; +#endif + +using std::ifstream; +using std::getline; +using std::endl; +using std::vector; +using std::set; +using boost::regex; +using boost::regex_match; + +#ifndef USE_INCLUDED_STRING +using boost::smatch; +#else +using boost::cmatch; +#endif -// This should perhaps be placed in LyXLex -static -string readLine(FILE *file) +// TODO: in no particular order +// - get rid of the extern BufferList and the call to +// BufferList::updateIncludedTeXfiles, this should either +// be done before calling LaTeX::funcs or in a completely +// different way. +// - the bibtex command options should be supported. +// - the makeindex style files should be taken care of with +// the dependency mechanism. +// - makeindex commandline options should be supported +// - somewhere support viewing of bibtex and makeindex log files. +// - we should perhaps also scan the bibtex log file +// - we should perhaps also scan the bibtex log file + +extern BufferList bufferlist; + +namespace { + +void showRunMessage(LyXFunc * lf, unsigned int count) { - if (feof(file)) - return string(); - - int i = 0; - char s[512]; - - do { - s[i] = fgetc(file); - i++; - } while (!feof(file) && s[i-1] != '\n' && i<510); - s[i] = '\0'; - string tmp; - if (i == 1 && feof(file)) - ; - else - tmp = s; - - return tmp; + string str = bformat(_("Waiting for LaTeX run number %1$s"), tostr(count)); + lf->dispatch(FuncRequest(LFUN_MESSAGE, str)); } - +}; /* * CLASS TEXERRORS */ -// I did not leave this inlined because DEC cxx does not like -// variables declarations in inlined code (JMarc) -TeXErrors::~TeXErrors() +void TeXErrors::insertError(int line, string const & error_desc, + string const & error_text) { - Error *tmp; - while (errors) { - tmp = errors->next_error; - delete errors; - errors = tmp; - } + Error newerr(line, error_desc, error_text); + errors.push_back(newerr); } -void TeXErrors::scanError(LyXLex &lex) +bool operator==(Aux_Info const & a, Aux_Info const & o) { - string token = lex.GetString(); - // Sometimes the error string goes over more than one - // line, and we need to get them all. - string errstr; - string tmp = frontStrip(readLine(lex.getFile())); - if (tmp == "\n" || tmp.empty()) { - tmp = frontStrip(readLine(lex.getFile())); - if (contains(tmp, "See the LaTeX manual")) { - do { - tmp = readLine(lex.getFile()); - } while (!tmp.empty() && !contains(tmp, "...")); - } - tmp = frontStrip(readLine(lex.getFile())); - } - - while ((tmp != "\n" || !contains(errstr, "l.")) - && !prefixIs(tmp, "! ") - && !contains(tmp, "(job aborted") - && !tmp.empty()) { - errstr += tmp; - tmp = frontStrip(readLine(lex.getFile())); - } - lyxerr.debug() << "tmp: " << errstr << endl; - int line = 0; - // unfortunately the error line is not always given - // by "l.###" in the beginning of the error string - // therefore we must search for "l.###" in the error - // msg. - if (contains(errstr, "l.")) { - // We make a const copy to make [] fast. (Asger) - string const es(errstr); - for (string::size_type i = 2; i < es.length(); ++i) { - if (es[i-2] == 'l' && es[i-1] == '.' && - (es[i] >= '0' && es[i]<= '9')) { - line = atoi(es.c_str() + i); - break; - } - } - } - insertError(line, token, errstr); - - if (prefixIs(tmp, "! ")) { - scanError(lex); - } + return a.aux_file == o.aux_file && + a.citations == o.citations && + a.databases == o.databases && + a.styles == o.styles; } -bool TeXErrors::getFirstError(int *line, string *text) +bool operator!=(Aux_Info const & a, Aux_Info const & o) { - next_error = errors; - if (next_error) { - *line = next_error->error_in_line; - *text = next_error->error_desc + "\n" + next_error->error_text; - next_error = next_error->next_error; - return true; - } - return false; + return !(a == o); } -bool TeXErrors::getNextError(int *line, string *text) -{ - if (next_error) { - *line = next_error->error_in_line; - *text = next_error->error_desc + "\n" + next_error->error_text; - next_error = next_error->next_error; - return true; - } - return false; -} - +/* + * CLASS LaTeX + */ -void TeXErrors::insertError(int line, string const &error_desc, - string const &error_text) +LaTeX::LaTeX(string const & latex, LatexRunParams const & rp, + string const & f, string const & p) + : cmd(latex), file(f), path(p), runparams(rp) { - Error *newerr = new Error(line, error_desc, error_text); - if (errors) { - Error *tmperr = errors; - while (tmperr->next_error) tmperr = tmperr->next_error; - tmperr->next_error = newerr; - } else { - errors = newerr; - } + num_errors = 0; + depfile = file + ".dep"; + if (prefixIs(cmd, "pdf")) { // Do we use pdflatex ? + depfile += "-pdf"; + output_file = ChangeExtension(file,".pdf"); + } else { + output_file = ChangeExtension(file,".dvi"); + } } -void TeXErrors::printErrors() +void LaTeX::deleteFilesOnError() const { - lyxerr << "Printing errors." << endl; - if (errors) { - Error *tmperr = errors; - do { - lyxerr << "Error in line " - << tmperr->error_in_line - << ": " << tmperr->error_desc - << '\n' << tmperr->error_text << endl; - tmperr = tmperr->next_error; - } while (tmperr); - } -} + // currently just a dummy function. + // What files do we have to delete? -void TeXErrors::printWarnings() -{ -} + // This will at least make latex do all the runs + lyx::unlink(depfile); + // but the reason for the error might be in a generated file... -void TeXErrors::printStatus() -{ - lyxerr << "Error struct:" - << "\n status: " << status - << "\n no err: " << number_of_errors << endl; - if (status == LaTeX::NO_ERRORS) lyxerr << "NO_ERRORS" << endl; - if (status & LaTeX::NO_LOGFILE) lyxerr << "NO_LOGFILE" << endl; - if (status & LaTeX::NO_OUTPUT) lyxerr << "NO_OUTPUT" << endl; - if (status & LaTeX::UNDEF_REF) lyxerr << "UNDEF_REF" << endl; - if (status & LaTeX::RERUN) lyxerr << "RERUN" << endl; - if (status & LaTeX::TEX_ERROR) lyxerr << "TEX_ERROR" << endl; - if (status & LaTeX::TEX_WARNING) lyxerr << "TEX_WARNING" << endl; - if (status & LaTeX::NO_FILE) lyxerr << "NO_FILE" << endl; -} + string const ofname = OnlyFilename(file); + // bibtex file + string const bbl = ChangeExtension(ofname, ".bbl"); + lyx::unlink(bbl); -/* - * CLASS LaTeX - */ + // makeindex file + string const ind = ChangeExtension(ofname, ".ind"); + lyx::unlink(ind); -LaTeX::LaTeX(string const & latex, string const & f, string const & p) - : cmd(latex), file(f), path(p) -{ - tex_files = NO_FILES; - file_count = sizeof(all_files) / sizeof(texfile_struct); - num_errors = 0; - depfile = file + ".dep"; + // Also remove the aux file + string const aux = ChangeExtension(ofname, ".aux"); + lyx::unlink(aux); } -int LaTeX::run(TeXErrors &terr, MiniBuffer *minib) +int LaTeX::run(TeXErrors & terr, LyXFunc * lfun) // We know that this function will only be run if the lyx buffer // has been changed. We also know that a newly written .tex file // is always different from the previous one because of the date // in it. However it seems safe to run latex (at least) on time each // time the .tex file changes. { - int scanres = LaTeX::NO_ERRORS; + int scanres = NO_ERRORS; unsigned int count = 0; // number of times run num_errors = 0; // just to make sure. - const unsigned int MAX_RUN = 6; + unsigned int const MAX_RUN = 6; DepTable head; // empty head bool rerun = false; // rerun requested - + // The class LaTeX does not know the temp path. - bufferlist.updateIncludedTeXfiles(GetCWD()); - + bufferlist.updateIncludedTeXfiles(lyx::getcwd(), runparams); + // Never write the depfile if an error was encountered. - + // 0 // first check if the file dependencies exist: // ->If it does exist @@ -273,43 +183,73 @@ int LaTeX::run(TeXErrors &terr, MiniBuffer *minib) // run latex once (we need to run latex once anyway) and // remake the dependency file. // + FileInfo fi(depfile); - if (fi.exist()) { + bool had_depfile = fi.exist(); + bool run_bibtex = false; + string aux_file = OnlyFilename(ChangeExtension(file, "aux")); + + if (had_depfile) { + lyxerr[Debug::DEPEND] << "Dependency file exists" << endl; // Read the dep file: - head.read(depfile); + had_depfile = head.read(depfile); + } + + if (had_depfile) { // Update the checksums head.update(); - - lyxerr[Debug::LATEX] << "Dependency file exists" << endl; - if (head.sumchange()) { - ++count; - lyxerr[Debug::LATEX] - << "Dependency file has changed\n" - << "Run #" << count << endl; - minib->Set(string(_("LaTeX run number ")) + tostr(count)); - minib->Store(); - this->operator()(); - scanres = scanLogFile(terr); - if (scanres & LaTeX::ERRORS) return scanres; // return on error + // Can't just check if anything has changed because it might have aborted + // on error last time... in which cas we need to re-run latex + // and collect the error messages (even if they are the same). + if (!FileInfo(output_file).exist()) { + lyxerr[Debug::DEPEND] + << "re-running LaTeX because output file doesn't exist." << endl; + } else if (!head.sumchange()) { + lyxerr[Debug::DEPEND] << "return no_change" << endl; + return NO_CHANGE; } else { - lyxerr[Debug::LATEX] << "return no_change" << endl; - return LaTeX::NO_CHANGE; + lyxerr[Debug::DEPEND] + << "Dependency file has changed" << endl; } - } else { - ++count; - lyxerr[Debug::LATEX] << "Dependency file does not exist\n" - << "Run #" << count << endl; - head.insert(file, true); - minib->Set(string(_("LaTeX run number ")) + tostr(count)); - minib->Store(); - this->operator()(); + + if (head.extchanged(".bib") || head.extchanged(".bst")) + run_bibtex = true; + } else + lyxerr[Debug::DEPEND] + << "Dependency file does not exist, or has wrong format" << endl; + + /// We scan the aux file even when had_depfile = false, + /// because we can run pdflatex on the file after running latex on it, + /// in which case we will not need to run bibtex again. + vector bibtex_info_old; + if (!run_bibtex) + bibtex_info_old = scanAuxFiles(aux_file); + + ++count; + lyxerr[Debug::LATEX] << "Run #" << count << endl; + if (lfun) { + showRunMessage(lfun, count); + } + + startscript(); + scanres = scanLogFile(terr); + if (scanres & ERROR_RERUN) { + lyxerr[Debug::LATEX] << "Rerunning LaTeX" << endl; + startscript(); scanres = scanLogFile(terr); - if (scanres & LaTeX::ERRORS) return scanres; // return on error } + if (scanres & ERRORS) { + deleteFilesOnError(); + return scanres; // return on error + } + + vector const bibtex_info = scanAuxFiles(aux_file); + if (!run_bibtex && bibtex_info_old != bibtex_info) + run_bibtex = true; + // update the dependencies. deplog(head); // reads the latex log - deptex(head); // checks for latex files head.update(); // 0.5 @@ -318,26 +258,39 @@ int LaTeX::run(TeXErrors &terr, MiniBuffer *minib) // And if there were undefined citations or changes in references // the .aux file is checked for signs of bibtex. Bibtex is then run // if needed. - + // run makeindex - if (head.haschanged(ChangeExtension(file, ".idx", true))) { + if (head.haschanged(OnlyFilename(ChangeExtension(file, ".idx")))) { // no checks for now - minib->Set(_("Running MakeIndex.")); - minib->Store(); - rerun=runMakeIndex(ChangeExtension(file,".idx",true)); + lyxerr[Debug::LATEX] << "Running MakeIndex." << endl; + if (lfun) { + lfun->dispatch(FuncRequest(LFUN_MESSAGE, _("Running MakeIndex."))); + } + + rerun = runMakeIndex(OnlyFilename(ChangeExtension(file, ".idx"))); } // run bibtex - if (scanres & LaTeX::UNDEF_CIT || scanres & LaTeX::RERUN) { + // if (scanres & UNDEF_CIT || scanres & RERUN || run_bibtex) + if (scanres & UNDEF_CIT || run_bibtex) { // Here we must scan the .aux file and look for // "\bibdata" and/or "\bibstyle". If one of those // tags is found -> run bibtex and set rerun = true; // no checks for now - minib->Set(_("Running BibTeX.")); - minib->Store(); - rerun = runBibTeX(ChangeExtension(file, ".aux", true)); + lyxerr[Debug::LATEX] << "Running BibTeX." << endl; + if (lfun) { + lfun->dispatch(FuncRequest(LFUN_MESSAGE, _("Running BibTeX."))); + } + + updateBibtexDependencies(head, bibtex_info); + rerun |= runBibTeX(bibtex_info); + } else if (!had_depfile) { + /// If we run pdflatex on the file after running latex on it, + /// then we do not need to run bibtex, but we do need to + /// insert the .bib and .bst files into the .dep-pdf file. + updateBibtexDependencies(head, bibtex_info); } - + // 1 // we know on this point that latex has been run once (or we just // returned) and the question now is to decide if we need to run @@ -353,19 +306,26 @@ int LaTeX::run(TeXErrors &terr, MiniBuffer *minib) if (rerun || head.sumchange()) { rerun = false; ++count; + lyxerr[Debug::DEPEND] + << "Dep. file has changed or rerun requested" << endl; lyxerr[Debug::LATEX] - << "Dep. file has changed or rerun requested\n" << "Run #" << count << endl; - minib->Set(string(_("LaTeX run number ")) + tostr(count)); - minib->Store(); - this->operator()(); + if (lfun) { + showRunMessage(lfun, count); + } + + startscript(); scanres = scanLogFile(terr); - if (scanres & LaTeX::ERRORS) return scanres; // return on error + if (scanres & ERRORS) { + deleteFilesOnError(); + return scanres; // return on error + } + // update the depedencies deplog(head); // reads the latex log head.update(); } else { - lyxerr[Debug::LATEX] << "Dep. file has NOT changed" << endl; + lyxerr[Debug::DEPEND] << "Dep. file has NOT changed" << endl; } // 1.5 @@ -375,15 +335,18 @@ int LaTeX::run(TeXErrors &terr, MiniBuffer *minib) // again to make sure everything is redone correctly. // Also there should be no need to run the external programs any // more after this. - + // run makeindex if the .idx has changed or was generated. - if (head.haschanged(ChangeExtension(file, ".idx", true))) { + if (head.haschanged(OnlyFilename(ChangeExtension(file, ".idx")))) { // no checks for now - minib->Set(_("Running MakeIndex.")); - minib->Store(); - rerun = runMakeIndex(ChangeExtension(file, ".idx", true)); + lyxerr[Debug::LATEX] << "Running MakeIndex." << endl; + if (lfun) { + lfun->dispatch(FuncRequest(LFUN_MESSAGE, _("Running MakeIndex."))); + } + + rerun = runMakeIndex(OnlyFilename(ChangeExtension(file, ".idx"))); } - + // 2 // we will only run latex more if the log file asks for it. // or if the sumchange() is true. @@ -394,18 +357,24 @@ int LaTeX::run(TeXErrors &terr, MiniBuffer *minib) // -> rerun not asked for: // just return (fall out of bottom of func) // - while ((head.sumchange() || rerun || (scanres & LaTeX::RERUN)) + while ((head.sumchange() || rerun || (scanres & RERUN)) && count < MAX_RUN) { // Yes rerun until message goes away, or until // MAX_RUNS are reached. rerun = false; ++count; lyxerr[Debug::LATEX] << "Run #" << count << endl; - minib->Set(string(_("LaTeX run number ")) + tostr(count)); - minib->Store(); - this->operator()(); + if (lfun) { + showRunMessage(lfun, count); + } + + startscript(); scanres = scanLogFile(terr); - if (scanres & LaTeX::ERRORS) return scanres; // return on error + if (scanres & ERRORS) { + deleteFilesOnError(); + return scanres; // return on error + } + // keep this updated head.update(); } @@ -417,89 +386,182 @@ int LaTeX::run(TeXErrors &terr, MiniBuffer *minib) } -int LaTeX::operator()() +int LaTeX::startscript() { #ifndef __EMX__ - string tmp = cmd + ' ' + file + " > /dev/null"; + string tmp = cmd + ' ' + QuoteName(file) + " > /dev/null"; #else // cmd.exe (OS/2) causes SYS0003 error at "/dev/null" string tmp = cmd + ' ' + file + " > nul"; #endif - Systemcalls one; - return one.Startscript(Systemcalls::System, tmp); + Systemcall one; + return one.startscript(Systemcall::Wait, tmp); } -bool LaTeX::runMakeIndex(string const &file) +bool LaTeX::runMakeIndex(string const & f) { lyxerr[Debug::LATEX] << "idx file has been made," " running makeindex on file " - << file << endl; + << f << endl; // It should be possible to set the switches for makeindex // sorting style and such. It would also be very convenient // to be able to make style files from within LyX. This has - // to come for a later time. (0.13 perhaps?) + // to come for a later time. string tmp = "makeindex -c -q "; - tmp += file; - Systemcalls one; - one.Startscript(Systemcalls::System, tmp); + tmp += f; + Systemcall one; + one.startscript(Systemcall::Wait, tmp); return true; } -bool LaTeX::runBibTeX(string const &file) +vector const +LaTeX::scanAuxFiles(string const & file) +{ + vector result; + + result.push_back(scanAuxFile(file)); + + for (int i = 1; i < 1000; ++i) { + string file2 = ChangeExtension(file, "") + '.' + tostr(i) + + ".aux"; + FileInfo fi(file2); + if (!fi.exist()) + break; + result.push_back(scanAuxFile(file2)); + } + return result; +} + + +Aux_Info const LaTeX::scanAuxFile(string const & file) { - LyXLex lex(0, 0); + Aux_Info result; + result.aux_file = file; + scanAuxFile(file, result); + return result; +} + + +void LaTeX::scanAuxFile(string const & file, Aux_Info & aux_info) +{ + lyxerr[Debug::LATEX] << "Scanning aux file: " << file << endl; + + ifstream ifs(file.c_str()); string token; - if (!lex.setFile(file)) { - // unable to open .aux file - // return at once - return false; + regex reg1("\\\\citation\\{([^}]+)\\}"); + regex reg2("\\\\bibdata\\{([^}]+)\\}"); + regex reg3("\\\\bibstyle\\{([^}]+)\\}"); + regex reg4("\\\\@input\\{([^}]+)\\}"); + + while (getline(ifs, token)) { + token = rtrim(token, "\r"); +#ifndef USE_INCLUDED_STRING + smatch sub; +#else + cmatch sub; +#endif + if (regex_match(STRCONV(token), sub, reg1)) { + string data = STRCONV(sub.str(1)); + while (!data.empty()) { + string citation; + data = split(data, citation, ','); + lyxerr[Debug::LATEX] << "Citation: " + << citation << endl; + aux_info.citations.insert(citation); + } + } else if (regex_match(STRCONV(token), sub, reg2)) { + string data = sub.STRCONV(str(1)); + // data is now all the bib files separated by ',' + // get them one by one and pass them to the helper + while (!data.empty()) { + string database; + data = split(data, database, ','); + database = ChangeExtension(database, "bib"); + lyxerr[Debug::LATEX] << "BibTeX database: `" + << database << '\'' << endl; + aux_info.databases.insert(database); + } + } else if (regex_match(STRCONV(token), sub, reg3)) { + string style = STRCONV(sub.str(1)); + // token is now the style file + // pass it to the helper + style = ChangeExtension(style, "bst"); + lyxerr[Debug::LATEX] << "BibTeX style: `" + << style << '\'' << endl; + aux_info.styles.insert(style); + } else if (regex_match(STRCONV(token), sub, reg4)) { + string const file2 = STRCONV(sub.str(1)); + scanAuxFile(file2, aux_info); + } } +} - while (lex.IsOK()) { - if (lex.EatLine()) - token=lex.GetString(); - else // blank line in the file being read - continue; - if (contains(token, "\\bibdata{")) { - // run bibtex and - string tmp="bibtex "; - tmp += ChangeExtension(file, string(), true); - Systemcalls one; - one.Startscript(Systemcalls::System, tmp); - return true; +void LaTeX::updateBibtexDependencies(DepTable & dep, + vector const & bibtex_info) +{ + // Since a run of Bibtex mandates more latex runs it is ok to + // remove all ".bib" and ".bst" files. + dep.remove_files_with_extension(".bib"); + dep.remove_files_with_extension(".bst"); + //string aux = OnlyFilename(ChangeExtension(file, ".aux")); + + for (vector::const_iterator it = bibtex_info.begin(); + it != bibtex_info.end(); ++it) { + for (set::const_iterator it2 = it->databases.begin(); + it2 != it->databases.end(); ++it2) { + string file = findtexfile(*it2, "bib"); + if (!file.empty()) + dep.insert(file, true); + } + + for (set::const_iterator it2 = it->styles.begin(); + it2 != it->styles.end(); ++it2) { + string file = findtexfile(*it2, "bst"); + if (!file.empty()) + dep.insert(file, true); } - } - // bibtex was not run. - return false; } -int LaTeX::scanLogFile(TeXErrors &terr) +bool LaTeX::runBibTeX(vector const & bibtex_info) { - int retval = NO_ERRORS; - string tmp = ChangeExtension(file, ".log", true); - - LyXLex lex(0, 0); - if (!lex.setFile(tmp)) { - // unable to open file - // return at once - retval |= NO_LOGFILE; - return retval; + bool result = false; + for (vector::const_iterator it = bibtex_info.begin(); + it != bibtex_info.end(); ++it) { + if (it->databases.empty()) + continue; + result = true; + + string tmp = "bibtex "; + tmp += OnlyFilename(ChangeExtension(it->aux_file, string())); + Systemcall one; + one.startscript(Systemcall::Wait, tmp); } + // Return whether bibtex was run + return result; +} + + +int LaTeX::scanLogFile(TeXErrors & terr) +{ + int last_line = -1; + int line_count = 1; + int retval = NO_ERRORS; + string tmp = OnlyFilename(ChangeExtension(file, ".log")); + lyxerr[Debug::LATEX] << "Log file: " << tmp << endl; + ifstream ifs(tmp.c_str()); string token; - while (lex.IsOK()) { - if (lex.EatLine()) - token = lex.GetString(); - else // blank line in the file being read + while (getline(ifs, token)) { + lyxerr[Debug::LATEX] << "Log line: " << token << endl; + + if (token.empty()) continue; - lyxerr[Debug::LATEX] << token << endl; - if (prefixIs(token, "LaTeX Warning:")) { // Here shall we handle different // types of warnings @@ -524,58 +586,74 @@ int LaTeX::scanLogFile(TeXErrors &terr) && contains(token, "undefined")) { retval |= UNDEF_CIT; } - } else if (contains(token, "Rerun LaTeX.")) { - // at least longtable.sty might use this. + } else if (contains(token, "run BibTeX")) { + retval |= UNDEF_CIT; + } else if (contains(token, "Rerun LaTeX") || + contains(token, "Rerun to get")) { + // at least longtable.sty and bibtopic.sty + // might use this. + lyxerr[Debug::LATEX] + << "We should rerun." << endl; + retval |= RERUN; + } + } else if (token[0] == '(') { + if (contains(token, "Rerun LaTeX") || + contains(token, "Rerun to get")) { + // Used by natbib + lyxerr[Debug::LATEX] + << "We should rerun." << endl; retval |= RERUN; } - } else if (prefixIs(token, "! LaTeX Error:")) { - // Here shall we handle different - // types of errors - retval |= LATEX_ERROR; - lyxerr[Debug::LATEX] << "LaTeX Error." << endl; - // this is not correct yet - terr.scanError(lex); - num_errors++; } else if (prefixIs(token, "! ")) { // Ok, we have something that looks like a TeX Error // but what do we really have. // Just get the error description: - string desc(token); - desc.erase(0, 2); - - if (contains(desc, "Undefined control sequence")) { - retval |= TEX_ERROR; - lyxerr[Debug::LATEX] << "TeX Error." << endl; - terr.scanError(lex); - num_errors++; - } else { - // get the next line - lex.next(); - string tmp = lex.GetString(); - if (prefixIs(tmp, "l.")) { + string desc(token, 2); + if (contains(token, "LaTeX Error:")) + retval |= LATEX_ERROR; + // get the next line + string tmp; + int count = 0; + do { + if (!getline(ifs, tmp)) + break; + if (++count > 10) + break; + } while (!prefixIs(tmp, "l.")); + if (prefixIs(tmp, "l.")) { // we have a latex error - retval |= TEX_ERROR; - lyxerr[Debug::LATEX] - <<"TeX Error." << endl; + retval |= TEX_ERROR; + if (contains(desc, "Package babel Error: You haven't defined the language")) + retval |= ERROR_RERUN; // get the line number: - int line = 0; - sscanf(tmp.c_str(), "l.%d", &line); + int line = 0; + sscanf(tmp.c_str(), "l.%d", &line); // get the rest of the message: - string errstr; - lex.EatLine(); - tmp = lex.GetString(); - while ((tmp != "\n" || !contains(errstr, "l.")) - && !prefixIs(tmp, "! ") - && !contains(tmp, "(job aborted") - && !tmp.empty()) { - errstr += tmp; - errstr += "\n"; - lex.EatLine(); - tmp = lex.GetString(); - } + string errstr(tmp, tmp.find(' ')); + errstr += '\n'; + getline(ifs, tmp); + while (!contains(errstr, "l.") + && !tmp.empty() + && !prefixIs(tmp, "! ") + && !contains(tmp, "(job aborted")) { + errstr += tmp; + errstr += "\n"; + getline(ifs, tmp); + } + lyxerr[Debug::LATEX] + << "line: " << line << '\n' + << "Desc: " << desc << '\n' + << "Text: " << errstr << endl; + if (line == last_line) + ++line_count; + else { + line_count = 1; + last_line = line; + } + if (line_count <= 5) { terr.insertError(line, desc, errstr); - num_errors++; + ++num_errors; } } } else { @@ -587,7 +665,7 @@ int LaTeX::scanLogFile(TeXErrors &terr) retval |= TEX_WARNING; } else if (contains(token, "Rerun to get citations")) { // Natbib seems to use this. - retval |= RERUN; + retval |= UNDEF_CIT; } else if (contains(token, "No pages of output")) { // A dvi file was not created retval |= NO_OUTPUT; @@ -596,7 +674,8 @@ int LaTeX::scanLogFile(TeXErrors &terr) retval |= TOO_MANY_ERRORS; } } - } + } + lyxerr[Debug::LATEX] << "Log line: " << token << endl; return retval; } @@ -607,115 +686,107 @@ void LaTeX::deplog(DepTable & head) // files used by the LaTeX run. The files are then entered into the // dependency file. - string logfile = ChangeExtension(file, ".log", true); - FilePtr in(logfile, FilePtr::read); - bool not_eof = true; - if (in()) while (not_eof) { // We were able to open the file - // Now we read chars until we find a '(' - int c; - do { - c = fgetc(in()); - } while (c != EOF && c != '('); - if (c == EOF) { - // Nothing more we can do - not_eof = false; + string const logfile = OnlyFilename(ChangeExtension(file, ".log")); + + regex reg1("\\)* *\\(([^ )]+).*"); + regex reg2("File: ([^ ]+).*"); + regex reg3("No file ([^ ]+)\\..*"); + regex reg4("\\\\openout[0-9]+.*=.*`([^ ]+)'\\..*"); + // If an index should be created, MikTex does not write a line like + // \openout# = 'sample,idx'. + // but intstead only a line like this into the log: + // Writing index file sample.idx + regex reg5("Writing index file ([^ ]+).*"); + regex unwanted("^.*\\.(aux|log|dvi|bbl|ind|glo)$"); + + ifstream ifs(logfile.c_str()); + while (ifs) { + // Ok, the scanning of files here is not sufficient. + // Sometimes files are named by "File: xxx" only + // So I think we should use some regexps to find files instead. + // "(\([^ ]+\)" should match the "(file " variant + // "File: \([^ ]+\)" should match the "File: file" variant + string foundfile; + string token; + getline(ifs, token); + token = rtrim(token, "\r"); + if (token.empty()) continue; + +#ifndef USE_INCLUDED_STRING + smatch sub; +#else + cmatch sub; +#endif + if (regex_match(STRCONV(token), sub, reg1)) { + foundfile = STRCONV(sub.str(1)); + } else if (regex_match(STRCONV(token), sub, reg2)) { + foundfile = STRCONV(sub.str(1)); + } else if (regex_match(STRCONV(token), sub, reg3)) { + foundfile = STRCONV(sub.str(1)); + } else if (regex_match(STRCONV(token), sub, reg4)) { + foundfile = STRCONV(sub.str(1)); + } else if (regex_match(STRCONV(token), sub, reg5)) { + foundfile = STRCONV(sub.str(1)); + } else { continue; - } + } - // We now have c == '(', we now read the the sequence of - // chars until reaching EOL, or ' ' and put that into a string. + // convert from native os path to unix path + foundfile = os::internal_path(foundfile); - string foundfile; - c = fgetc(in()); - while (c != '\n' && c != ' ' && c != ')') { - foundfile += char(c); - c = fgetc(in()); - } - if (foundfile.empty()) continue; + lyxerr[Debug::DEPEND] << "Found file: " + << foundfile << endl; - lyxerr[Debug::LATEX] << "Found file: " - << foundfile << endl; // Ok now we found a file. - // Now we should make sure that - // this is a file that we can - // access through the normal - // paths: + // Now we should make sure that this is a file that we can + // access through the normal paths. + // We will not try any fancy search methods to + // find the file. + // (1) foundfile is an // absolute path and should // be inserted. if (AbsolutePath(foundfile)) { - lyxerr[Debug::LATEX] << "AbsolutePath file: " - << foundfile << endl; - // On inital insert we want to do the update at once + lyxerr[Debug::DEPEND] << "AbsolutePath file: " + << foundfile << endl; + // On initial insert we want to do the update at once // since this file can not be a file generated by // the latex run. - head.insert(foundfile, true); - continue; + if (FileInfo(foundfile).exist()) + head.insert(foundfile, true); } // (2) foundfile is in the tmpdir // insert it into head - if (FileInfo(OnlyFilename(foundfile)).exist()) { - if (suffixIs(foundfile, ".aux")) { - lyxerr[Debug::LATEX] << "We don't want " - << OnlyFilename(foundfile) - << " in the dep file" - << endl; + else if (FileInfo(OnlyFilename(foundfile)).exist()) { + if (regex_match(STRCONV(foundfile), unwanted)) { + lyxerr[Debug::DEPEND] + << "We don't want " + << OnlyFilename(foundfile) + << " in the dep file" + << endl; } else if (suffixIs(foundfile, ".tex")) { // This is a tex file generated by LyX // and latex is not likely to change this // during its runs. - lyxerr[Debug::LATEX] << "Tmpdir TeX file: " - << OnlyFilename(foundfile) - << endl; + lyxerr[Debug::DEPEND] + << "Tmpdir TeX file: " + << OnlyFilename(foundfile) + << endl; head.insert(foundfile, true); } else { - lyxerr[Debug::LATEX] << "In tmpdir file:" - << OnlyFilename(foundfile) - << endl; + lyxerr[Debug::DEPEND] + << "In tmpdir file:" + << OnlyFilename(foundfile) + << endl; head.insert(OnlyFilename(foundfile)); } - continue; - } - - // (3) the foundfile can be - // found in the same dir - // as the .lyx file and - // should be inserted. - PathPush(path); - if (FileInfo(foundfile).exist()) { - lyxerr << "LyX Strange: this should actually never" - " happen anymore, this it should be" - " handled by the Absolute check." - << endl; - lyxerr[Debug::LATEX] << "Same Directory file: " - << foundfile << endl; - head.insert(foundfile); - PathPop(); - continue; - } - PathPop(); - - lyxerr[Debug::LATEX] - << "Not a file or we are unable to find it." - << endl; + } else + lyxerr[Debug::DEPEND] + << "Not a file or we are unable to find it." + << endl; } -} - -void LaTeX::deptex(DepTable &head) -{ - int except = AUX|LOG|DVI|BBL|IND|GLO; - string tmp; - FileInfo fi; - for (int i = 0; i < file_count; i++) { - if (!(all_files[i].file & except)) { - tmp = ChangeExtension(file, - all_files[i].extension, - true); - lyxerr[Debug::LATEX] << "deptex: " << tmp << endl; - if (fi.newFile(tmp).exist()) - head.insert(tmp); - } - } + // Make sure that the main .tex file is in the dependancy file. + head.insert(OnlyFilename(file), true); }