X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBiblioInfo.cpp;h=84ea4f035f4241bef40b625a0e432e931ed1e2f5;hb=1d6573a330791fb34541f4092cd49e4559972489;hp=50ba5d8e097c6c6e1abe95d5b01b1bdf9e55c288;hpb=e73c866edf06654c3bcb429ccde2fa014822023c;p=lyx.git diff --git a/src/BiblioInfo.cpp b/src/BiblioInfo.cpp index 50ba5d8e09..84ea4f035f 100644 --- a/src/BiblioInfo.cpp +++ b/src/BiblioInfo.cpp @@ -6,6 +6,7 @@ * \author Angus Leeming * \author Herbert Voß * \author Richard Heck + * \author Julien Rioux * * Full author contact details are available in file CREDITS. */ @@ -18,24 +19,20 @@ #include "buffer_funcs.h" #include "Encoding.h" #include "InsetIterator.h" +#include "Language.h" #include "Paragraph.h" +#include "TextClass.h" #include "TocBackend.h" -#include "insets/Inset.h" -#include "insets/InsetBibitem.h" -#include "insets/InsetBibtex.h" -#include "insets/InsetInclude.h" - #include "support/convert.h" #include "support/debug.h" #include "support/docstream.h" #include "support/gettext.h" #include "support/lassert.h" #include "support/lstrings.h" +#include "support/regex.h" #include "support/textutils.h" -#include "boost/regex.hpp" - #include using namespace std; @@ -70,7 +67,7 @@ docstring familyName(docstring const & name) vector::const_iterator it = pieces.begin(); vector::const_iterator en = pieces.end(); for (; it != en; ++it) { - if ((*it).size() == 0) + if ((*it).empty()) continue; char_type const c = (*it)[0]; if (isLower(c)) @@ -86,13 +83,14 @@ docstring familyName(docstring const & name) for (; it != en; ++it) { if (!first) retval += " "; - else + else first = false; retval += *it; } return retval; } + // converts a string containing LaTeX commands into unicode // for display. docstring convertLaTeXCommands(docstring const & str) @@ -103,7 +101,7 @@ docstring convertLaTeXCommands(docstring const & str) bool scanning_cmd = false; bool scanning_math = false; bool escaped = false; // used to catch \$, etc. - while (val.size()) { + while (!val.empty()) { char_type const ch = val[0]; // if we're scanning math, we output everything until we @@ -113,7 +111,7 @@ docstring convertLaTeXCommands(docstring const & str) escaped = false; else if (ch == '\\') escaped = true; - else if (ch == '$') + else if (ch == '$') scanning_math = false; ret += ch; val = val.substr(1); @@ -173,14 +171,17 @@ docstring convertLaTeXCommands(docstring const & str) // unicodesymbols has things in the form: \"{u}, // whereas we may see things like: \"u. So we'll // look for that and change it, if necessary. - static boost::regex const reg("^\\\\\\W\\w"); - if (boost::regex_search(to_utf8(val), reg)) { + // FIXME: This is a sort of mini-tex2lyx. + // Use the real tex2lyx instead! + static lyx::regex const reg("^\\\\\\W\\w"); + if (lyx::regex_search(to_utf8(val), reg)) { val.insert(3, from_ascii("}")); val.insert(2, from_ascii("{")); } + bool termination; docstring rem; - docstring const cnvtd = Encodings::fromLaTeXCommand(val, rem, - Encodings::TEXT_CMD); + docstring const cnvtd = Encodings::fromLaTeXCommand(val, + Encodings::TEXT_CMD, termination, rem); if (!cnvtd.empty()) { // it did, so we'll take that bit and proceed with what's left ret += cnvtd; @@ -195,11 +196,48 @@ docstring convertLaTeXCommands(docstring const & str) return ret; } -// these are used in the expandFormat() routine, etc. -static string const pp_text = N_("pp."); -static string const ed_text = N_("ed."); -static string const edby_text = N_("ed. by"); +// Escape '<' and '>' and remove richtext markers (e.g. {!this is richtext!}) from a string. +docstring processRichtext(docstring const & str, bool richtext) +{ + docstring val = str; + docstring ret; + + bool scanning_rich = false; + while (!val.empty()) { + char_type const ch = val[0]; + if (ch == '{' && val.size() > 1 && val[1] == '!') { + // beginning of rich text + scanning_rich = true; + val = val.substr(2); + continue; + } + if (scanning_rich && ch == '!' && val.size() > 1 && val[1] == '}') { + // end of rich text + scanning_rich = false; + val = val.substr(2); + continue; + } + if (richtext) { + if (scanning_rich) + ret += ch; + else { + // we need to escape '<' and '>' + if (ch == '<') + ret += "<"; + else if (ch == '>') + ret += ">"; + else + ret += ch; + } + } else if (!scanning_rich /* && !richtext */) + ret += ch; + // else the character is discarded, which will happen only if + // richtext == false and we are scanning rich text + val = val.substr(1); + } + return ret; +} } // anon namespace @@ -216,7 +254,7 @@ BibTeXInfo::BibTeXInfo(docstring const & key, docstring const & type) {} -docstring const BibTeXInfo::getAbbreviatedAuthor() const +docstring const BibTeXInfo::getAbbreviatedAuthor(bool jurabib_style) const { if (!is_bibtex_) { docstring const opt = label(); @@ -226,7 +264,7 @@ docstring const BibTeXInfo::getAbbreviatedAuthor() const docstring authors; docstring const remainder = trim(split(opt, authors, '(')); if (remainder.empty()) - // in this case, we didn't find a "(", + // in this case, we didn't find a "(", // so we don't have author (year) return docstring(); return authors; @@ -236,31 +274,55 @@ docstring const BibTeXInfo::getAbbreviatedAuthor() const if (author.empty()) { author = convertLaTeXCommands(operator[]("editor")); if (author.empty()) - return bib_key_; + return author; } // FIXME Move this to a separate routine that can // be called from elsewhere. - // + // // OK, we've got some names. Let's format them. // Try to split the author list on " and " vector const authors = getVectorFromString(author, from_ascii(" and ")); - if (authors.size() == 2) - return bformat(_("%1$s and %2$s"), + if (jurabib_style && (authors.size() == 2 || authors.size() == 3)) { + docstring shortauthor = familyName(authors[0]) + + "/" + familyName(authors[1]); + if (authors.size() == 3) + shortauthor += "/" + familyName(authors[2]); + return shortauthor; + } + + if (authors.size() == 2 && authors[1] != "others") + return bformat(from_ascii("%1$s and %2$s"), familyName(authors[0]), familyName(authors[1])); - if (authors.size() > 2) - return bformat(_("%1$s et al."), familyName(authors[0])); + if (authors.size() >= 2) + return bformat(from_ascii("%1$s et al."), + familyName(authors[0])); return familyName(authors[0]); } +docstring const BibTeXInfo::getAbbreviatedAuthor(Buffer const & buf, bool jurabib_style) const +{ + docstring const author = getAbbreviatedAuthor(jurabib_style); + if (!is_bibtex_) + return author; + vector const authors = getVectorFromString(author, from_ascii(" and ")); + if (authors.size() == 2) + return bformat(buf.B_("%1$s and %2$s"), authors[0], authors[1]); + docstring::size_type const idx = author.rfind(from_ascii(" et al.")); + if (idx != docstring::npos) + return bformat(buf.B_("%1$s et al."), author.substr(0, idx)); + return author; +} + + docstring const BibTeXInfo::getYear() const { - if (is_bibtex_) + if (is_bibtex_) return operator[]("year"); docstring const opt = label(); @@ -269,7 +331,7 @@ docstring const BibTeXInfo::getYear() const docstring authors; docstring tmp = split(opt, authors, '('); - if (tmp.empty()) + if (tmp.empty()) // we don't have author (year) return docstring(); docstring year; @@ -287,154 +349,178 @@ docstring const BibTeXInfo::getXRef() const namespace { - string parseOptions(string const & format, string & optkey, - string & ifpart, string & elsepart); - - // Calls parseOptions to deal with an embedded option, such as: - // {%number%[[, no.~%number%]]} - // which must appear at the start of format. ifelsepart gets the - // whole of the option, and we return what's left after the option. - // we return format if there is an error. - string parseEmbeddedOption(string const & format, string & ifelsepart) - { - LASSERT(format[0] == '{' && format[1] == '%', return format); - string optkey; - string ifpart; - string elsepart; - string const rest = parseOptions(format, optkey, ifpart, elsepart); - if (format == rest) { // parse error - LYXERR0("ERROR! Couldn't parse `" << format <<"'."); - return format; - } - LASSERT(rest.size() <= format.size(), /* */); - ifelsepart = format.substr(0, format.size() - rest.size()); - return rest; + +string parseOptions(string const & format, string & optkey, + string & ifpart, string & elsepart); + +// Calls parseOptions to deal with an embedded option, such as: +// {%number%[[, no.~%number%]]} +// which must appear at the start of format. ifelsepart gets the +// whole of the option, and we return what's left after the option. +// we return format if there is an error. +string parseEmbeddedOption(string const & format, string & ifelsepart) +{ + LASSERT(format[0] == '{' && format[1] == '%', return format); + string optkey; + string ifpart; + string elsepart; + string const rest = parseOptions(format, optkey, ifpart, elsepart); + if (format == rest) { // parse error + LYXERR0("ERROR! Couldn't parse `" << format <<"'."); + return format; } - - - // Gets a "clause" from a format string, where the clause is - // delimited by '[[' and ']]'. Returns what is left after the - // clause is removed, and returns format if there is an error. - string getClause(string const & format, string & clause) - { - string fmt = format; - // remove '[[' - fmt = fmt.substr(2); - // we'll remove characters from the front of fmt as we - // deal with them - while (fmt.size()) { - if (fmt[0] == ']' && fmt.size() > 1 && fmt[1] == ']') { - // that's the end - fmt = fmt.substr(2); - break; + LASSERT(rest.size() <= format.size(), /* */); + ifelsepart = format.substr(0, format.size() - rest.size()); + return rest; +} + + +// Gets a "clause" from a format string, where the clause is +// delimited by '[[' and ']]'. Returns what is left after the +// clause is removed, and returns format if there is an error. +string getClause(string const & format, string & clause) +{ + string fmt = format; + // remove '[[' + fmt = fmt.substr(2); + // we'll remove characters from the front of fmt as we + // deal with them + while (!fmt.empty()) { + if (fmt[0] == ']' && fmt.size() > 1 && fmt[1] == ']') { + // that's the end + fmt = fmt.substr(2); + break; + } + // check for an embedded option + if (fmt[0] == '{' && fmt.size() > 1 && fmt[1] == '%') { + string part; + string const rest = parseEmbeddedOption(fmt, part); + if (fmt == rest) { + LYXERR0("ERROR! Couldn't parse embedded option in `" << format <<"'."); + return format; } - // check for an embedded option - if (fmt[0] == '{' && fmt.size() > 1 && fmt[1] == '%') { - string part; - string const rest = parseEmbeddedOption(fmt, part); - if (fmt == rest) { - LYXERR0("ERROR! Couldn't parse embedded option in `" << format <<"'."); - return format; - } - clause += part; - fmt = rest; - } else { // it's just a normal character + clause += part; + fmt = rest; + } else { // it's just a normal character clause += fmt[0]; fmt = fmt.substr(1); - } } - return fmt; } + return fmt; +} - // parse an options string, which must appear at the start of the - // format parameter. puts the parsed bits in optkey, ifpart, and - // elsepart and returns what's left after the option is removed. - // if there's an error, it returns format itself. - string parseOptions(string const & format, string & optkey, - string & ifpart, string & elsepart) - { - LASSERT(format[0] == '{' && format[1] == '%', return format); - // strip '{%' - string fmt = format.substr(2); - size_t pos = fmt.find('%'); // end of key - if (pos == string::npos) { - LYXERR0("Error parsing `" << format <<"'. Can't find end of key."); - return format; - } - optkey = fmt.substr(0,pos); - fmt = fmt.substr(pos + 1); - // [[format]] should be next - if (fmt[0] != '[' || fmt[1] != '[') { - LYXERR0("Error parsing `" << format <<"'. Can't find '[[' after key."); - return format; - } +// parse an options string, which must appear at the start of the +// format parameter. puts the parsed bits in optkey, ifpart, and +// elsepart and returns what's left after the option is removed. +// if there's an error, it returns format itself. +string parseOptions(string const & format, string & optkey, + string & ifpart, string & elsepart) +{ + LASSERT(format[0] == '{' && format[1] == '%', return format); + // strip '{%' + string fmt = format.substr(2); + size_t pos = fmt.find('%'); // end of key + if (pos == string::npos) { + LYXERR0("Error parsing `" << format <<"'. Can't find end of key."); + return format; + } + optkey = fmt.substr(0,pos); + fmt = fmt.substr(pos + 1); + // [[format]] should be next + if (fmt[0] != '[' || fmt[1] != '[') { + LYXERR0("Error parsing `" << format <<"'. Can't find '[[' after key."); + return format; + } - string curfmt = fmt; - fmt = getClause(curfmt, ifpart); - if (fmt == curfmt) { - LYXERR0("Error parsing `" << format <<"'. Couldn't get if clause."); - return format; - } + string curfmt = fmt; + fmt = getClause(curfmt, ifpart); + if (fmt == curfmt) { + LYXERR0("Error parsing `" << format <<"'. Couldn't get if clause."); + return format; + } - if (fmt[0] == '}') // we're done, no else clause - return fmt.substr(1); - - // else part should follow - if (fmt[0] != '[' || fmt[1] != '[') { - LYXERR0("Error parsing `" << format <<"'. Can't find else clause."); - return format; - } - - curfmt = fmt; - fmt = getClause(curfmt, elsepart); - // we should be done - if (fmt == curfmt || fmt[0] != '}') { - LYXERR0("Error parsing `" << format <<"'. Can't find end of option."); - return format; - } + if (fmt[0] == '}') // we're done, no else clause return fmt.substr(1); + + // else part should follow + if (fmt[0] != '[' || fmt[1] != '[') { + LYXERR0("Error parsing `" << format <<"'. Can't find else clause."); + return format; + } + + curfmt = fmt; + fmt = getClause(curfmt, elsepart); + // we should be done + if (fmt == curfmt || fmt[0] != '}') { + LYXERR0("Error parsing `" << format <<"'. Can't find end of option."); + return format; + } + return fmt.substr(1); } + } // anon namespace -docstring BibTeXInfo::expandFormat(string const & format, - BibTeXInfo const * const xref, bool richtext) const +docstring BibTeXInfo::expandFormat(string const & format, + BibTeXInfo const * const xref, int & counter, Buffer const & buf, + docstring before, docstring after, docstring dialog, bool next) const { + // incorrect use of macros could put us in an infinite loop + static int max_passes = 5000; docstring ret; // return value string key; bool scanning_key = false; bool scanning_rich = false; + CiteEngineType const engine_type = buf.params().citeEngineType(); string fmt = format; - // we'll remove characters from the front of fmt as we + // we'll remove characters from the front of fmt as we // deal with them - while (fmt.size()) { + while (!fmt.empty()) { + if (counter++ > max_passes) { + LYXERR0("Recursion limit reached while parsing `" + << format << "'."); + return _("ERROR!"); + } + char_type thischar = fmt[0]; - if (thischar == '%') { + if (thischar == '%') { // beginning or end of key - if (scanning_key) { + if (scanning_key) { // end of key scanning_key = false; // so we replace the key with its value, which may be empty - if (key == "pp_text") - ret += _(pp_text); - else if (key == "ed_text") - ret += _(ed_text); - else if(key == "edby_text") - ret += _(edby_text); - else { - docstring const val = getValueForKey(key, xref); + if (key[0] == '!') { + // macro + string const val = + buf.params().documentClass().getCiteMacro(engine_type, key); + fmt = val + fmt.substr(1); + continue; + } else if (key[0] == '_') { + // a translatable bit + string const val = + buf.params().documentClass().getCiteMacro(engine_type, key); + docstring const trans = + translateIfPossible(from_utf8(val), buf.params().language->code()); + ret += trans; + } else { + docstring const val = + getValueForKey(key, buf, before, after, dialog, xref); + if (!scanning_rich) + ret += from_ascii("{!!}"); ret += val; + if (!scanning_rich) + ret += from_ascii("{!!}"); } - key.clear(); } else { // beginning of key + key.clear(); scanning_key = true; } - } - else if (thischar == '{') { + } + else if (thischar == '{') { // beginning of option? if (scanning_key) { LYXERR0("ERROR: Found `{' when scanning key in `" << format << "'."); @@ -446,42 +532,48 @@ docstring BibTeXInfo::expandFormat(string const & format, string optkey; string ifpart; string elsepart; - string const newfmt = + string const newfmt = parseOptions(fmt, optkey, ifpart, elsepart); if (newfmt == fmt) // parse error return _("ERROR!"); fmt = newfmt; - docstring const val = getValueForKey(optkey, xref); - if (!val.empty()) - ret += expandFormat(ifpart, xref, richtext); + docstring const val = + getValueForKey(optkey, buf, before, after, dialog, xref); + if (optkey == "next" && next) + ret += from_utf8(ifpart); // without expansion + else if (!val.empty()) + ret += expandFormat(ifpart, xref, counter, buf, + before, after, dialog, next); else if (!elsepart.empty()) - ret += expandFormat(elsepart, xref, richtext); + ret += expandFormat(elsepart, xref, counter, buf, + before, after, dialog, next); // fmt will have been shortened for us already - continue; + continue; } if (fmt[1] == '!') { // beginning of rich text scanning_rich = true; fmt = fmt.substr(2); + ret += from_ascii("{!"); continue; } } - // we are here if the '{' was at the end of the format. hmm. + // we are here if '{' was not followed by % or !. + // So it's just a character. ret += thischar; } - else if (scanning_rich && thischar == '!' + else if (scanning_rich && thischar == '!' && fmt.size() > 1 && fmt[1] == '}') { // end of rich text scanning_rich = false; fmt = fmt.substr(2); + ret += from_ascii("!}"); continue; } else if (scanning_key) key += char(thischar); - else if (richtext || !scanning_rich) + else ret += thischar; - // else the character is discarded, which will happen only if - // richtext == false and we are scanning rich text fmt = fmt.substr(1); } // for loop if (scanning_key) { @@ -496,28 +588,13 @@ docstring BibTeXInfo::expandFormat(string const & format, } -namespace { - -// FIXME These would be better read from a file, so that they -// could be customized. - - static string articleFormat = "%author%, \"%title%\", {!!}%journal%{!!} {%volume%[[ %volume%{%number%[[, %number%]]}]]} (%year%){%pages%[[, %pp_text% %pages%]]}.{%note%[[ %note%]]}"; - - static string bookFormat = "{%author%[[%author%]][[%editor%, %ed_text%]]}, {!!}%title%{!!}{%volume%[[ vol. %volume%]][[{%number%[[no. %number%]]}]]}{%edition%[[%edition%]]} ({%address%[[%address%: ]]}%publisher%, %year%).{%note%[[ %note%]]}"; - - static string inSomething = "%author%, \"%title%\", in{%editor%[[ %editor%, %ed_text%,]]} {!!}%booktitle%{!!}{%volume%[[ vol. %volume%]][[{%number%[[no. %number%]]}]]}{%edition%[[%edition%]]} ({%address%[[%address%: ]]}%publisher%, %year%){%pages%[[, %pp_text% %pages%]]}.{%note%[[ %note%]]}"; - - static string thesis = "%author%, %title% ({%address%[[%address%: ]]}%school%, %year%).{%note%[[ %note%]]}"; - - static string defaultFormat = "{%author%[[%author%, ]][[{%editor%[[%editor%, %ed_text%, ]]}]]}\"%title%\"{%journal%[[, {!!}%journal%{!!}]][[{%publisher%[[, %publisher%]][[{%institution%[[, %institution%]]}]]}]]}{%year%[[ (%year%)]]}{%pages%[[, %pages%]]}."; - -} - docstring const & BibTeXInfo::getInfo(BibTeXInfo const * const xref, - bool richtext) const + Buffer const & buf, bool richtext) const { - if (!info_.empty()) + if (!richtext && !info_.empty()) return info_; + if (richtext && !info_richtext_.empty()) + return info_richtext_; if (!is_bibtex_) { BibTeXInfo::const_iterator it = find(from_ascii("ref")); @@ -525,23 +602,41 @@ docstring const & BibTeXInfo::getInfo(BibTeXInfo const * const xref, return info_; } - if (entry_type_ == "article") - info_ = expandFormat(articleFormat, xref, richtext); - else if (entry_type_ == "book") - info_ = expandFormat(bookFormat, xref, richtext); - else if (entry_type_.substr(0,2) == "in") - info_ = expandFormat(inSomething, xref, richtext); - else if (entry_type_ == "phdthesis" || entry_type_ == "mastersthesis") - info_ = expandFormat(thesis, xref, richtext); - else - info_ = expandFormat(defaultFormat, xref, richtext); - - if (!info_.empty()) - info_ = convertLaTeXCommands(info_); + CiteEngineType const engine_type = buf.params().citeEngineType(); + DocumentClass const & dc = buf.params().documentClass(); + string const & format = dc.getCiteFormat(engine_type, to_utf8(entry_type_)); + int counter = 0; + info_ = expandFormat(format, xref, counter, buf, + docstring(), docstring(), docstring(), false); + + if (!info_.empty()) { + info_richtext_ = convertLaTeXCommands(processRichtext(info_, true)); + info_ = convertLaTeXCommands(processRichtext(info_, false)); + if (richtext) + return info_richtext_; + } return info_; } +docstring const BibTeXInfo::getLabel(BibTeXInfo const * const xref, + Buffer const & buf, string const & format, bool richtext, + docstring before, docstring after, docstring dialog, bool next) const +{ + docstring loclabel; + + int counter = 0; + loclabel = expandFormat(format, xref, counter, buf, + before, after, dialog, next); + + if (!loclabel.empty() && !next) { + loclabel = processRichtext(loclabel, richtext); + loclabel = convertLaTeXCommands(loclabel); + } + return loclabel; +} + + docstring const & BibTeXInfo::operator[](docstring const & field) const { BibTeXInfo::const_iterator it = find(field); @@ -550,21 +645,65 @@ docstring const & BibTeXInfo::operator[](docstring const & field) const static docstring const empty_value = docstring(); return empty_value; } - - + + docstring const & BibTeXInfo::operator[](string const & field) const { return operator[](from_ascii(field)); } -docstring BibTeXInfo::getValueForKey(string const & key, - BibTeXInfo const * const xref) const +docstring BibTeXInfo::getValueForKey(string const & key, Buffer const & buf, + docstring const & before, docstring const & after, docstring const & dialog, + BibTeXInfo const * const xref) const { - docstring const ret = operator[](key); - if (!ret.empty() || !xref) + docstring ret = operator[](key); + if (ret.empty() && xref) + ret = (*xref)[key]; + if (!ret.empty()) return ret; - return (*xref)[key]; + // some special keys + // FIXME: dialog, textbefore and textafter have nothing to do with this + if (key == "dialog") + return dialog; + else if (key == "entrytype") + return entry_type_; + else if (key == "key") + return bib_key_; + else if (key == "label") + return label_; + else if (key == "abbrvauthor") + // Special key to provide abbreviated author names. + return getAbbreviatedAuthor(buf, false); + else if (key == "shortauthor") + // When shortauthor is not defined, jurabib automatically + // provides jurabib-style abbreviated author names. We do + // this as well. + return getAbbreviatedAuthor(buf, true); + else if (key == "shorttitle") { + // When shorttitle is not defined, jurabib uses for `article' + // and `periodical' entries the form `journal volume [year]' + // and for other types of entries it uses the `title' field. + if (entry_type_ == "article" || entry_type_ == "periodical") + return operator[]("journal") + " " + operator[]("volume") + + " [" + operator[]("year") + "]"; + else + return operator[]("title"); + } else if (key == "bibentry") { + // Special key to provide the full bibliography entry: see getInfo() + CiteEngineType const engine_type = buf.params().citeEngineType(); + DocumentClass const & dc = buf.params().documentClass(); + string const & format = dc.getCiteFormat(engine_type, to_utf8(entry_type_)); + int counter = 0; + return expandFormat(format, xref, counter, buf, + docstring(), docstring(), docstring(), false); + } else if (key == "textbefore") + return before; + else if (key == "textafter") + return after; + else if (key == "year") + return getYear(); + return ret; } @@ -575,14 +714,16 @@ docstring BibTeXInfo::getValueForKey(string const & key, ////////////////////////////////////////////////////////////////////// namespace { + // A functor for use with sort, leading to case insensitive sorting - class compareNoCase: public binary_function - { - public: - bool operator()(docstring const & s1, docstring const & s2) const { - return compare_no_case(s1, s2) < 0; - } - }; +class compareNoCase: public binary_function +{ +public: + bool operator()(docstring const & s1, docstring const & s2) const { + return compare_no_case(s1, s2) < 0; + } +}; + } // namespace anon @@ -621,13 +762,13 @@ vector const BiblioInfo::getEntries() const } -docstring const BiblioInfo::getAbbreviatedAuthor(docstring const & key) const +docstring const BiblioInfo::getAbbreviatedAuthor(docstring const & key, Buffer const & buf) const { BiblioInfo::const_iterator it = find(key); if (it == end()) return docstring(); BibTeXInfo const & data = it->second; - return data.getAbbreviatedAuthor(); + return data.getAbbreviatedAuthor(buf, false); } @@ -652,10 +793,12 @@ docstring const BiblioInfo::getYear(docstring const & key, bool use_modifier) co // let's try the crossref docstring const xref = data.getXRef(); if (xref.empty()) - return _("No year"); // no luck + // no luck + return docstring(); BiblioInfo::const_iterator const xrefit = find(xref); if (xrefit == end()) - return _("No year"); // no luck again + // no luck again + return docstring(); BibTeXInfo const & xref_data = xrefit->second; year = xref_data.getYear(); } @@ -665,11 +808,21 @@ docstring const BiblioInfo::getYear(docstring const & key, bool use_modifier) co } -docstring const BiblioInfo::getInfo(docstring const & key, bool richtext) const +docstring const BiblioInfo::getYear(docstring const & key, Buffer const & buf, bool use_modifier) const +{ + docstring const year = getYear(key, use_modifier); + if (year.empty()) + return buf.B_("No year"); + return year; +} + + +docstring const BiblioInfo::getInfo(docstring const & key, + Buffer const & buf, bool richtext) const { BiblioInfo::const_iterator it = find(key); if (it == end()) - return docstring(); + return docstring(_("Bibliography entry not found!")); BibTeXInfo const & data = it->second; BibTeXInfo const * xrefptr = 0; docstring const xref = data.getXRef(); @@ -678,7 +831,39 @@ docstring const BiblioInfo::getInfo(docstring const & key, bool richtext) const if (xrefit != end()) xrefptr = &(xrefit->second); } - return data.getInfo(xrefptr, richtext); + return data.getInfo(xrefptr, buf, richtext); +} + + +docstring const BiblioInfo::getLabel(vector const & keys, + Buffer const & buf, string const & style, bool richtext, + docstring const & before, docstring const & after, docstring const & dialog) const +{ + CiteEngineType const engine_type = buf.params().citeEngineType(); + DocumentClass const & dc = buf.params().documentClass(); + string const & format = dc.getCiteFormat(engine_type, style, "cite"); + docstring ret = from_utf8(format); + vector::const_iterator key = keys.begin(); + vector::const_iterator ken = keys.end(); + for (; key != ken; ++key) { + BiblioInfo::const_iterator it = find(*key); + BibTeXInfo empty_data; + empty_data.key(*key); + BibTeXInfo & data = empty_data; + BibTeXInfo const * xrefptr = 0; + if (it != end()) { + data = it->second; + docstring const xref = data.getXRef(); + if (!xref.empty()) { + BiblioInfo::const_iterator const xrefit = find(xref); + if (xrefit != end()) + xrefptr = &(xrefit->second); + } + } + ret = data.getLabel(xrefptr, buf, to_utf8(ret), richtext, + before, after, dialog, key+1 != ken); + } + return ret; } @@ -691,159 +876,49 @@ bool BiblioInfo::isBibtex(docstring const & key) const } - vector const BiblioInfo::getCiteStrings( - docstring const & key, Buffer const & buf) const -{ - CiteEngine const engine = buf.params().citeEngine(); - if (engine == ENGINE_BASIC || engine == ENGINE_NATBIB_NUMERICAL) - return getNumericalStrings(key, buf); - else - return getAuthorYearStrings(key, buf); -} - - -vector const BiblioInfo::getNumericalStrings( - docstring const & key, Buffer const & buf) const + vector const & keys, vector const & styles, + Buffer const & buf, bool richtext, docstring const & before, + docstring const & after, docstring const & dialog) const { if (empty()) return vector(); - docstring const author = getAbbreviatedAuthor(key); - docstring const year = getYear(key); - if (author.empty() || year.empty()) - return vector(); - - vector const & styles = citeStyles(buf.params().citeEngine()); - + string style; vector vec(styles.size()); for (size_t i = 0; i != vec.size(); ++i) { - docstring str; - - switch (styles[i]) { - case CITE: - case CITEP: - str = from_ascii("[#ID]"); - break; - - case NOCITE: - str = _("Add to bibliography only."); - break; - - case CITET: - str = author + " [#ID]"; - break; - - case CITEALT: - str = author + " #ID"; - break; - - case CITEALP: - str = from_ascii("#ID"); - break; - - case CITEAUTHOR: - str = author; - break; - - case CITEYEAR: - str = year; - break; - - case CITEYEARPAR: - str = '(' + year + ')'; - break; - } - - vec[i] = str; + style = styles[i].cmd; + vec[i] = getLabel(keys, buf, style, richtext, before, after, dialog); } return vec; } -vector const BiblioInfo::getAuthorYearStrings( - docstring const & key, Buffer const & buf) const -{ - if (empty()) - return vector(); - - docstring const author = getAbbreviatedAuthor(key); - docstring const year = getYear(key); - if (author.empty() || year.empty()) - return vector(); - - vector const & styles = citeStyles(buf.params().citeEngine()); - - vector vec(styles.size()); - for (size_t i = 0; i != vec.size(); ++i) { - docstring str; - - switch (styles[i]) { - case CITE: - // jurabib only: Author/Annotator - // (i.e. the "before" field, 2nd opt arg) - str = author + "/<" + _("before") + '>'; - break; - - case NOCITE: - str = _("Add to bibliography only."); - break; - - case CITET: - str = author + " (" + year + ')'; - break; - - case CITEP: - str = '(' + author + ", " + year + ')'; - break; - - case CITEALT: - str = author + ' ' + year ; - break; - - case CITEALP: - str = author + ", " + year ; - break; - - case CITEAUTHOR: - str = author; - break; - - case CITEYEAR: - str = year; - break; - - case CITEYEARPAR: - str = '(' + year + ')'; - break; - } - vec[i] = str; - } - return vec; -} - - void BiblioInfo::mergeBiblioInfo(BiblioInfo const & info) { bimap_.insert(info.begin(), info.end()); + field_names_.insert(info.field_names_.begin(), info.field_names_.end()); + entry_types_.insert(info.entry_types_.begin(), info.entry_types_.end()); } namespace { - // used in xhtml to sort a list of BibTeXInfo objects - bool lSorter(BibTeXInfo const * lhs, BibTeXInfo const * rhs) - { - docstring const lauth = lhs->getAbbreviatedAuthor(); - docstring const rauth = rhs->getAbbreviatedAuthor(); - docstring const lyear = lhs->getYear(); - docstring const ryear = rhs->getYear(); - docstring const ltitl = lhs->operator[]("title"); - docstring const rtitl = rhs->operator[]("title"); - return (lauth < rauth) - || (lauth == rauth && lyear < ryear) - || (lauth == rauth && lyear == ryear && ltitl < rtitl); - } + +// used in xhtml to sort a list of BibTeXInfo objects +bool lSorter(BibTeXInfo const * lhs, BibTeXInfo const * rhs) +{ + docstring const lauth = lhs->getAbbreviatedAuthor(); + docstring const rauth = rhs->getAbbreviatedAuthor(); + docstring const lyear = lhs->getYear(); + docstring const ryear = rhs->getYear(); + docstring const ltitl = lhs->operator[]("title"); + docstring const rtitl = rhs->operator[]("title"); + return (lauth < rauth) + || (lauth == rauth && lyear < ryear) + || (lauth == rauth && lyear == ryear && ltitl < rtitl); +} + } @@ -866,9 +941,9 @@ void BiblioInfo::collectCitedEntries(Buffer const & buf) } if (citekeys.empty()) return; - + // We have a set of the keys used in this document. - // We will now convert it to a list of the BibTeXInfo objects used in + // We will now convert it to a list of the BibTeXInfo objects used in // this document... vector bi; set::const_iterator cit = citekeys.begin(); @@ -881,7 +956,7 @@ void BiblioInfo::collectCitedEntries(Buffer const & buf) } // ...and sort it. sort(bi.begin(), bi.end(), lSorter); - + // Now we can write the sorted keys vector::const_iterator bit = bi.begin(); vector::const_iterator ben = bi.end(); @@ -893,9 +968,8 @@ void BiblioInfo::collectCitedEntries(Buffer const & buf) void BiblioInfo::makeCitationLabels(Buffer const & buf) { collectCitedEntries(buf); - CiteEngine const engine = buf.params().citeEngine(); - bool const numbers = - (engine == ENGINE_BASIC || engine == ENGINE_NATBIB_NUMERICAL); + CiteEngineType const engine_type = buf.params().citeEngineType(); + bool const numbers = (engine_type == ENGINE_TYPE_NUMERICAL); int keynumber = 0; char modifier = 0; @@ -933,11 +1007,33 @@ void BiblioInfo::makeCitationLabels(Buffer const & buf) } else { modifier = 0; } - entry.setModifier(modifier); + entry.setModifier(modifier); // remember the last one last = biit; } } + // Set the labels + it = cited_entries_.begin(); + for (; it != en; ++it) { + map::iterator const biit = bimap_.find(*it); + // this shouldn't happen, but... + if (biit == bimap_.end()) + // ...fail gracefully, anyway. + continue; + BibTeXInfo & entry = biit->second; + if (numbers) { + entry.label(entry.citeNumber()); + } else { + docstring const auth = entry.getAbbreviatedAuthor(buf, false); + // we do it this way so as to access the xref, if necessary + // note that this also gives us the modifier + docstring const year = getYear(*it, buf, true); + if (!auth.empty() && !year.empty()) + entry.label(auth + ' ' + year); + else + entry.label(entry.key()); + } + } } @@ -947,114 +1043,38 @@ void BiblioInfo::makeCitationLabels(Buffer const & buf) // ////////////////////////////////////////////////////////////////////// -namespace { - - -char const * const citeCommands[] = { - "cite", "citet", "citep", "citealt", "citealp", - "citeauthor", "citeyear", "citeyearpar", "nocite" }; - -unsigned int const nCiteCommands = - sizeof(citeCommands) / sizeof(char *); - -CiteStyle const citeStylesArray[] = { - CITE, CITET, CITEP, CITEALT, CITEALP, - CITEAUTHOR, CITEYEAR, CITEYEARPAR, NOCITE }; - -unsigned int const nCiteStyles = - sizeof(citeStylesArray) / sizeof(CiteStyle); - -CiteStyle const citeStylesFull[] = { - CITET, CITEP, CITEALT, CITEALP, CITEAUTHOR }; - -unsigned int const nCiteStylesFull = - sizeof(citeStylesFull) / sizeof(CiteStyle); - -CiteStyle const citeStylesUCase[] = { - CITET, CITEP, CITEALT, CITEALP, CITEAUTHOR }; - -unsigned int const nCiteStylesUCase = - sizeof(citeStylesUCase) / sizeof(CiteStyle); - -} // namespace anon - CitationStyle citationStyleFromString(string const & command) { - CitationStyle s; + CitationStyle cs; if (command.empty()) - return s; + return cs; string cmd = command; if (cmd[0] == 'C') { - s.forceUpperCase = true; + cs.forceUpperCase = true; cmd[0] = 'c'; } size_t const n = cmd.size() - 1; - if (cmd != "cite" && cmd[n] == '*') { - s.full = true; + if (cmd[n] == '*') { + cs.fullAuthorList = true; cmd = cmd.substr(0, n); } - char const * const * const last = citeCommands + nCiteCommands; - char const * const * const ptr = find(citeCommands, last, cmd); - - if (ptr != last) { - size_t idx = ptr - citeCommands; - s.style = citeStylesArray[idx]; - } - return s; + cs.cmd = cmd; + return cs; } -string citationStyleToString(const CitationStyle & s) -{ - string cite = citeCommands[s.style]; - if (s.full) { - CiteStyle const * last = citeStylesFull + nCiteStylesFull; - if (std::find(citeStylesFull, last, s.style) != last) - cite += '*'; - } - - if (s.forceUpperCase) { - CiteStyle const * last = citeStylesUCase + nCiteStylesUCase; - if (std::find(citeStylesUCase, last, s.style) != last) - cite[0] = 'C'; - } - - return cite; -} - -vector citeStyles(CiteEngine engine) +string citationStyleToString(const CitationStyle & cs) { - unsigned int nStyles = 0; - unsigned int start = 0; - - switch (engine) { - case ENGINE_BASIC: - nStyles = 2; - start = 0; - break; - case ENGINE_NATBIB_AUTHORYEAR: - case ENGINE_NATBIB_NUMERICAL: - nStyles = nCiteStyles - 1; - start = 1; - break; - case ENGINE_JURABIB: - nStyles = nCiteStyles; - start = 0; - break; - } - - vector styles(nStyles); - size_t i = 0; - int j = start; - for (; i != styles.size(); ++i, ++j) - styles[i] = citeStylesArray[j]; - - return styles; + string cmd = cs.cmd; + if (cs.forceUpperCase) + cmd[0] = 'C'; + if (cs.fullAuthorList) + cmd += '*'; + return cmd; } } // namespace lyx -