X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsetbibtex.C;h=fa604fddd381159f9b1e90203dcfaab0bbae44ed;hb=e28331ed63062dea10d0a21b9ec12034b4b17b9a;hp=feec01537bd4d7ca777faa1cd8630126e68beec3;hpb=68b7ef25fb7d2da230d3eb11d6737701abfc2e64;p=lyx.git diff --git a/src/insets/insetbibtex.C b/src/insets/insetbibtex.C index feec01537b..fa604fddd3 100644 --- a/src/insets/insetbibtex.C +++ b/src/insets/insetbibtex.C @@ -16,40 +16,54 @@ #include "bufferparams.h" #include "dispatchresult.h" #include "debug.h" +#include "encoding.h" #include "funcrequest.h" -#include "LaTeXFeatures.h" #include "gettext.h" +#include "LaTeXFeatures.h" #include "metricsinfo.h" #include "outputparams.h" +#include "frontends/Alert.h" + #include "support/filetools.h" #include "support/lstrings.h" +#include "support/lyxlib.h" #include "support/os.h" #include "support/path.h" -#include - -using lyx::support::ascii_lowercase; -using lyx::support::ChangeExtension; -using lyx::support::contains; -using lyx::support::findtexfile; -using lyx::support::IsFileReadable; -using lyx::support::ltrim; -using lyx::support::MakeAbsPath; -using lyx::support::Path; -using lyx::support::prefixIs; -using lyx::support::rtrim; -using lyx::support::split; -using lyx::support::subst; -using lyx::support::tokenPos; -using lyx::support::trim; - -namespace os = lyx::support::os; +#include + + +namespace lyx { + +using support::absolutePath; +using support::ascii_lowercase; +using support::changeExtension; +using support::contains; +using support::copy; +using support::DocFileName; +using support::FileName; +using support::findtexfile; +using support::isFileReadable; +using support::latex_path; +using support::ltrim; +using support::makeAbsPath; +using support::makeRelPath; +using support::Path; +using support::prefixIs; +using support::removeExtension; +using support::rtrim; +using support::split; +using support::subst; +using support::tokenPos; +using support::trim; + +namespace Alert = frontend::Alert; +namespace os = support::os; using std::endl; using std::getline; using std::string; -using std::ifstream; using std::ostream; using std::pair; using std::vector; @@ -60,38 +74,58 @@ InsetBibtex::InsetBibtex(InsetCommandParams const & p) {} -std::auto_ptr InsetBibtex::clone() const +std::auto_ptr InsetBibtex::doClone() const { return std::auto_ptr(new InsetBibtex(*this)); } -void InsetBibtex::priv_dispatch(LCursor & cur, FuncRequest & cmd) +void InsetBibtex::doDispatch(LCursor & cur, FuncRequest & cmd) { switch (cmd.action) { case LFUN_INSET_MODIFY: { - InsetCommandParams p; - InsetCommandMailer::string2params("bibtex", cmd.argument, p); - if (!p.getCmdName().empty()) + InsetCommandParams p("bibtex"); + InsetCommandMailer::string2params("bibtex", to_utf8(cmd.argument()), p); + if (!p.getCmdName().empty()) { setParams(p); + cur.buffer().updateBibfilesCache(); + } else + cur.noUpdate(); break; } default: - InsetCommand::priv_dispatch(cur, cmd); + InsetCommand::doDispatch(cur, cmd); break; } } -string const InsetBibtex::getScreenLabel(Buffer const &) const +docstring const InsetBibtex::getScreenLabel(Buffer const &) const { - return _("BibTeX Generated References"); + return _("BibTeX Generated Bibliography"); } -int InsetBibtex::latex(Buffer const & buffer, ostream & os, +namespace { + +string normalize_name(Buffer const & buffer, OutputParams const & runparams, + string const & name, string const & ext) +{ + string const fname = makeAbsPath(name, buffer.filePath()).absFilename(); + if (absolutePath(name) || !isFileReadable(FileName(fname + ext))) + return name; + else if (!runparams.nice) + return fname; + else + return makeRelPath(fname, buffer.getMasterBuffer()->filePath()); +} + +} + + +int InsetBibtex::latex(Buffer const & buffer, odocstream & os, OutputParams const & runparams) const { // the sequence of the commands: @@ -104,27 +138,75 @@ int InsetBibtex::latex(Buffer const & buffer, ostream & os, // 3. \btPrint{Cited|NotCited|All} // 4. \end{btSect} - // the database string - string adb; - string db_in = getContents(); - db_in = split(db_in, adb, ','); - // If we generate in a temp dir, we might need to give an - // absolute path there. This is a bit complicated since we can - // have a comma-separated list of bibliographies - string db_out; - while (!adb.empty()) { - if (!runparams.nice && - IsFileReadable(MakeAbsPath(adb, buffer.filePath())+".bib")) - adb = os::external_path(MakeAbsPath(adb, - buffer.filePath())); - db_out += adb; - db_out += ','; - db_in = split(db_in, adb,','); + // Database(s) + // If we are processing the LaTeX file in a temp directory then + // copy the .bib databases to this temp directory, mangling their + // names in the process. Store this mangled name in the list of + // all databases. + // (We need to do all this because BibTeX *really*, *really* + // can't handle "files with spaces" and Windows users tend to + // use such filenames.) + // Otherwise, store the (maybe absolute) path to the original, + // unmangled database name. + typedef boost::char_separator Separator; + typedef boost::tokenizer Tokenizer; + + Separator const separator(from_ascii(",").c_str()); + // The tokenizer must not be called with temporary strings, since + // it does not make a copy and uses iterators of the string further + // down. getParam returns a reference, so this is OK. + Tokenizer const tokens(getParam("bibfiles"), separator); + Tokenizer::const_iterator const begin = tokens.begin(); + Tokenizer::const_iterator const end = tokens.end(); + + odocstringstream dbs; + for (Tokenizer::const_iterator it = begin; it != end; ++it) { + docstring const input = trim(*it); + // FIXME UNICODE + string utf8input(to_utf8(input)); + string database = + normalize_name(buffer, runparams, utf8input, ".bib"); + FileName const try_in_file(makeAbsPath(database + ".bib", buffer.filePath())); + bool const not_from_texmf = isFileReadable(try_in_file); + + if (!runparams.inComment && !runparams.dryrun && !runparams.nice && + not_from_texmf) { + + // mangledFilename() needs the extension + DocFileName const in_file = DocFileName(try_in_file); + database = removeExtension(in_file.mangledFilename()); + FileName const out_file(makeAbsPath(database + ".bib", + buffer.getMasterBuffer()->temppath())); + + bool const success = copy(in_file, out_file); + if (!success) { + lyxerr << "Failed to copy '" << in_file + << "' to '" << out_file << "'" + << endl; + } + } + + if (it != begin) + dbs << ','; + // FIXME UNICODE + dbs << from_utf8(latex_path(database)); + } + docstring const db_out = dbs.str(); + + // Post this warning only once. + static bool warned_about_spaces = false; + if (!warned_about_spaces && + runparams.nice && db_out.find(' ') != docstring::npos) { + warned_about_spaces = true; + + Alert::warning(_("Export Warning!"), + _("There are spaces in the paths to your BibTeX databases.\n" + "BibTeX will be unable to find them.")); + } - db_out = rtrim(db_out, ","); // Style-Options - string style = getOptions(); // maybe empty! and with bibtotoc + string style = to_utf8(getParam("options")); // maybe empty! and with bibtotoc string bibtotoc; if (prefixIs(style, "bibtotoc")) { bibtotoc = "bibtotoc"; @@ -134,27 +216,56 @@ int InsetBibtex::latex(Buffer const & buffer, ostream & os, } // line count - int i = 0; + int nlines = 0; - if (!runparams.nice - && IsFileReadable(MakeAbsPath(style, buffer.filePath()) + ".bst")) { - style = MakeAbsPath(style, buffer.filePath()); + if (!style.empty()) { + string base = + normalize_name(buffer, runparams, style, ".bst"); + FileName const try_in_file(makeAbsPath(base + ".bst", buffer.filePath())); + bool const not_from_texmf = isFileReadable(try_in_file); + // If this style does not come from texmf and we are not + // exporting to .tex copy it to the tmp directory. + // This prevents problems with spaces and 8bit charcaters + // in the file name. + if (!runparams.inComment && !runparams.dryrun && !runparams.nice && + not_from_texmf) { + // use new style name + DocFileName const in_file = DocFileName(try_in_file); + base = removeExtension(in_file.mangledFilename()); + FileName const out_file(makeAbsPath(base + ".bst", + buffer.getMasterBuffer()->temppath())); + bool const success = copy(in_file, out_file); + if (!success) { + lyxerr << "Failed to copy '" << in_file + << "' to '" << out_file << "'" + << endl; + } + } + // FIXME UNICODE + os << "\\bibliographystyle{" + << from_utf8(latex_path(normalize_name(buffer, runparams, base, ".bst"))) + << "}\n"; + nlines += 1; } - if (!style.empty()) { - os << "\\bibliographystyle{" << style << "}\n"; - i += 1; + // Post this warning only once. + static bool warned_about_bst_spaces = false; + if (!warned_about_bst_spaces && runparams.nice && contains(style, ' ')) { + warned_about_bst_spaces = true; + Alert::warning(_("Export Warning!"), + _("There are spaces in the path to your BibTeX style file.\n" + "BibTeX will be unable to find it.")); } - if (buffer.params().use_bibtopic){ + if (!db_out.empty() && buffer.params().use_bibtopic){ os << "\\begin{btSect}{" << db_out << "}\n"; - string btprint = getSecOptions(); + docstring btprint = getParam("btprint"); if (btprint.empty()) // default - btprint = "btPrintCited"; + btprint = from_ascii("btPrintCited"); os << "\\" << btprint << "\n" << "\\end{btSect}\n"; - i += 3; + nlines += 3; } // bibtotoc-Option @@ -182,26 +293,27 @@ int InsetBibtex::latex(Buffer const & buffer, ostream & os, } } - if (!buffer.params().use_bibtopic){ + if (!db_out.empty() && !buffer.params().use_bibtopic){ os << "\\bibliography{" << db_out << "}\n"; - i += 1; + nlines += 1; } - return i; + return nlines; } -vector const InsetBibtex::getFiles(Buffer const & buffer) const +vector const InsetBibtex::getFiles(Buffer const & buffer) const { Path p(buffer.filePath()); - vector vec; + vector vec; string tmp; - string bibfiles = getContents(); + // FIXME UNICODE + string bibfiles = to_utf8(getParam("bibfiles")); bibfiles = split(bibfiles, tmp, ','); while (!tmp.empty()) { - string file = findtexfile(ChangeExtension(tmp, "bib"), "bib"); + FileName const file = findtexfile(changeExtension(tmp, "bib"), "bib"); lyxerr[Debug::LATEX] << "Bibfile: " << file << endl; // If we didn't find a matching file name just fail silently @@ -218,36 +330,48 @@ vector const InsetBibtex::getFiles(Buffer const & buffer) const // This method returns a comma separated list of Bibtex entries void InsetBibtex::fillWithBibKeys(Buffer const & buffer, - std::vector > & keys) const + std::vector > & keys) const { - vector const files = getFiles(buffer); - for (vector::const_iterator it = files.begin(); + vector const files = getFiles(buffer); + for (vector::const_iterator it = files.begin(); it != files.end(); ++ it) { // This is a _very_ simple parser for Bibtex database // files. All it does is to look for lines starting // in @ and not being @preamble and @string entries. // It does NOT do any syntax checking! - ifstream ifs(it->c_str()); - string linebuf0; + + // Officially bibtex does only support ASCII, but in practice + // you can use the encoding of the main document as long as + // some elements like keys and names are pure ASCII. Therefore + // we convert the file from the buffer encoding. + // We don't restrict keys to ASCII in LyX, since our own + // InsetBibitem can generate non-ASCII keys, and nonstandard + // 8bit clean bibtex forks exist. + idocfstream ifs(it->toFilesystemEncoding().c_str(), + std::ios_base::in, + buffer.params().encoding().iconvName()); + docstring linebuf0; while (getline(ifs, linebuf0)) { - string linebuf = trim(linebuf0); - if (linebuf.empty()) continue; - if (prefixIs(linebuf, "@")) { + docstring linebuf = trim(linebuf0); + if (linebuf.empty()) + continue; + if (prefixIs(linebuf, '@')) { linebuf = subst(linebuf, '{', '('); - string tmp; + docstring tmp; linebuf = split(linebuf, tmp, '('); tmp = ascii_lowercase(tmp); - if (!prefixIs(tmp, "@string") - && !prefixIs(tmp, "@preamble")) { + if (!prefixIs(tmp, from_ascii("@string")) && + !prefixIs(tmp, from_ascii("@preamble"))) { linebuf = split(linebuf, tmp, ','); tmp = ltrim(tmp, " \t"); if (!tmp.empty()) { - keys.push_back(pair(tmp,string())); + // FIXME UNICODE + keys.push_back(pair( + to_utf8(tmp), docstring())); } } - } else if (!keys.empty()) { - keys.back().second += linebuf + "\n"; - } + } else if (!keys.empty()) + keys.back().second += linebuf + '\n'; } } } @@ -255,11 +379,12 @@ void InsetBibtex::fillWithBibKeys(Buffer const & buffer, bool InsetBibtex::addDatabase(string const & db) { - string contents(getContents()); - if (!contains(contents, db)) { - if (!contents.empty()) - contents += ','; - setContents(contents + db); + // FIXME UNICODE + string bibfiles(to_utf8(getParam("bibfiles"))); + if (tokenPos(bibfiles, ',', db) == -1) { + if (!bibfiles.empty()) + bibfiles += ','; + setParam("bibfiles", from_utf8(bibfiles + db)); return true; } return false; @@ -268,16 +393,18 @@ bool InsetBibtex::addDatabase(string const & db) bool InsetBibtex::delDatabase(string const & db) { - if (contains(getContents(), db)) { + // FIXME UNICODE + string bibfiles(to_utf8(getParam("bibfiles"))); + if (contains(bibfiles, db)) { + int const n = tokenPos(bibfiles, ',', db); string bd = db; - int const n = tokenPos(getContents(), ',', bd); if (n > 0) { - // Weird code, would someone care to explain this?(Lgb) - string tmp(", "); - tmp += bd; - setContents(subst(getContents(), tmp, ", ")); + // this is not the first database + string tmp = ',' + bd; + setParam("bibfiles", from_utf8(subst(bibfiles, tmp, string()))); } else if (n == 0) - setContents(split(getContents(), bd, ',')); + // this is the first (or only) database + setParam("bibfiles", from_utf8(split(bibfiles, bd, ','))); else return false; } @@ -290,3 +417,6 @@ void InsetBibtex::validate(LaTeXFeatures & features) const if (features.bufferParams().use_bibtopic) features.require("bibtopic"); } + + +} // namespace lyx