X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBiblioInfo.cpp;h=f45d370ece5b432f7a781121d994b61e05cf1c13;hb=c7d29be153debac82e3d2e8865fcc849f0a5f40d;hp=b88546e7f135a9943fa759269ff9460b1fd2ffca;hpb=2a21c12eab4035b64d68a911a0e1f5008dfee1b3;p=lyx.git diff --git a/src/BiblioInfo.cpp b/src/BiblioInfo.cpp index b88546e7f1..f45d370ece 100644 --- a/src/BiblioInfo.cpp +++ b/src/BiblioInfo.cpp @@ -6,6 +6,8 @@ * \author Angus Leeming * \author Herbert Voß * \author Richard Heck + * \author Julien Rioux + * \author Jürgen Spitzmüller * * Full author contact details are available in file CREDITS. */ @@ -16,28 +18,25 @@ #include "Buffer.h" #include "BufferParams.h" #include "buffer_funcs.h" +#include "Citation.h" #include "Encoding.h" #include "InsetIterator.h" #include "Language.h" +#include "output_xhtml.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 #include using namespace std; @@ -48,53 +47,278 @@ namespace lyx { namespace { -// gets the "family name" from an author-type string -docstring familyName(docstring const & name) +// Remove placeholders from names +docstring renormalize(docstring const & input) { - if (name.empty()) - return docstring(); + docstring res = subst(input, from_ascii("$$space!"), from_ascii(" ")); + return subst(res, from_ascii("$$comma!"), from_ascii(",")); +} - // first we look for a comma, and take the last name to be everything - // preceding the right-most one, so that we also get the "jr" part. - docstring::size_type idx = name.rfind(','); - if (idx != docstring::npos) - return ltrim(name.substr(0, idx)); - // OK, so now we want to look for the last name. We're going to - // include the "von" part. This isn't perfect. +// Split the surname into prefix ("von-part") and family name +pair parseSurname(docstring const & sname) +{ + // Split the surname into its tokens + vector pieces = getVectorFromString(sname, from_ascii(" ")); + if (pieces.size() < 2) + return make_pair(docstring(), sname); + + // Now we look for pieces that begin with a lower case letter. + // All except for the very last token constitute the "von-part". + docstring prefix; + vector::const_iterator it = pieces.begin(); + vector::const_iterator const en = pieces.end(); + bool first = true; + for (; it != en; ++it) { + if ((*it).empty()) + continue; + // If this is the last piece, then what we now have is + // the family name, notwithstanding the casing. + if (it + 1 == en) + break; + char_type const c = (*it)[0]; + // If the piece starts with a upper case char, we assume + // this is part of the surname. + if (!isLower(c)) + break; + // Nothing of the former, so add this piece to the prename + if (!first) + prefix += " "; + else + first = false; + prefix += *it; + } + + // Reconstruct the family name. + // Note that if we left the loop with because it + 1 == en, + // then this will still do the right thing, i.e., make surname + // just be the last piece. + docstring surname; + first = true; + for (; it != en; ++it) { + if (!first) + surname += " "; + else + first = false; + surname += *it; + } + return make_pair(prefix, surname); +} + + +struct name_parts { + docstring surname; + docstring prename; + docstring suffix; + docstring prefix; +}; + + +// gets the name parts (prename, surname, prefix, suffix) from an author-type string +name_parts nameParts(docstring const & iname) +{ + name_parts res; + if (iname.empty()) + return res; + + // First we check for goupings (via {...}) and replace blanks and + // commas inside groups with temporary placeholders + docstring name; + int gl = 0; + docstring::const_iterator p = iname.begin(); + while (p != iname.end()) { + // count grouping level + if (*p == '{') + ++gl; + else if (*p == '}') + --gl; + // generate string with probable placeholders + if (*p == ' ' && gl > 0) + name += from_ascii("$$space!"); + else if (*p == ',' && gl > 0) + name += from_ascii("$$comma!"); + else + name += *p; + ++p; + } + + // Now we look for a comma, and take the last name to be everything + // preceding the right-most one, so that we also get the name suffix + // (aka "jr" part). + vector pieces = getVectorFromString(name); + if (pieces.size() > 1) { + // Whether we have a name suffix or not, the prename is + // always last item + res.prename = renormalize(pieces.back()); + // The family name, conversely, is always the first item. + // However, it might contain a prefix (aka "von" part) + docstring const sname = pieces.front(); + res.prefix = renormalize(parseSurname(sname).first); + res.surname = renormalize(parseSurname(sname).second); + // If we have three pieces (the maximum allowed by BibTeX), + // the second one is the name suffix. + if (pieces.size() > 2) + res.suffix = renormalize(pieces.at(1)); + return res; + } + + // OK, so now we want to look for the last name. // Split on spaces, to get various tokens. - vector pieces = getVectorFromString(name, from_ascii(" ")); - // If we only get two, assume the last one is the last name - if (pieces.size() <= 2) - return pieces.back(); + pieces = getVectorFromString(name, from_ascii(" ")); + // No space: Only a family name given + if (pieces.size() < 2) { + res.surname = renormalize(pieces.back()); + return res; + } + // If we get two pieces, assume "prename surname" + if (pieces.size() == 2) { + res.prename = renormalize(pieces.front()); + res.surname = renormalize(pieces.back()); + return res; + } - // Now we look for the first token that begins with a lower case letter. + // More than 3 pieces: A name prefix (aka "von" part) might be included. + // We look for the first piece that begins with a lower case letter + // (which is the name prefix, if it is not the last token) or the last token. + docstring prename; vector::const_iterator it = pieces.begin(); - vector::const_iterator en = pieces.end(); + vector::const_iterator const en = pieces.end(); + bool first = true; for (; it != en; ++it) { - if ((*it).size() == 0) + if ((*it).empty()) continue; char_type const c = (*it)[0]; + // If the piece starts with a lower case char, we assume + // this is the name prefix and thus prename is complete. if (isLower(c)) break; + // Same if this is the last piece, which is always the surname. + if (it + 1 == en) + break; + // Nothing of the former, so add this piece to the prename + if (!first) + prename += " "; + else + first = false; + prename += *it; } - if (it == en) // we never found a "von" - return pieces.back(); - - // reconstruct what we need to return - docstring retval; - bool first = true; + // Now reconstruct the family name and strip the prefix. + // Note that if we left the loop because it + 1 == en, + // then this will still do the right thing, i.e., make surname + // just be the last piece. + docstring surname; + first = true; for (; it != en; ++it) { if (!first) - retval += " "; - else + surname += " "; + else first = false; - retval += *it; + surname += *it; + } + res.prename = renormalize(prename); + res.prefix = renormalize(parseSurname(surname).first); + res.surname = renormalize(parseSurname(surname).second); + return res; +} + + +docstring constructName(docstring const & name, string const scheme) +{ + // re-constructs a name from name parts according + // to a given scheme + docstring const prename = nameParts(name).prename; + docstring const surname = nameParts(name).surname; + docstring const prefix = nameParts(name).prefix; + docstring const suffix = nameParts(name).suffix; + string res = scheme; + static regex const reg1("(.*)(\\{%prename%\\[\\[)([^\\]]+)(\\]\\]\\})(.*)"); + static regex const reg2("(.*)(\\{%suffix%\\[\\[)([^\\]]+)(\\]\\]\\})(.*)"); + static regex const reg3("(.*)(\\{%prefix%\\[\\[)([^\\]]+)(\\]\\]\\})(.*)"); + smatch sub; + // Changing the first parameter of regex_match() may corrupt the + // second one. In this case we use the temporary string tmp. + if (regex_match(scheme, sub, reg1)) { + res = sub.str(1); + if (!prename.empty()) + res += sub.str(3); + res += sub.str(5); + } + if (regex_match(res, sub, reg2)) { + string tmp = sub.str(1); + if (!suffix.empty()) + tmp += sub.str(3); + res = tmp + sub.str(5); } - return retval; + if (regex_match(res, sub, reg3)) { + string tmp = sub.str(1); + if (!prefix.empty()) + tmp += sub.str(3); + res = tmp + sub.str(5); + } + docstring result = from_ascii(res); + result = subst(result, from_ascii("%prename%"), prename); + result = subst(result, from_ascii("%surname%"), surname); + result = subst(result, from_ascii("%prefix%"), prefix); + result = subst(result, from_ascii("%suffix%"), suffix); + return result; } + +vector const getAuthors(docstring const & author) +{ + // We check for goupings (via {...}) and only consider " and " + // outside groups as author separator. This is to account + // for cases such as {{Barnes and Noble, Inc.}}, which + // need to be treated as one single family name. + // We use temporary placeholders in order to differentiate the + // diverse " and " cases. + + // First, we temporarily replace all ampersands. It is rather unusual + // in author names, but can happen (consider cases such as "C \& A Corp."). + docstring iname = subst(author, from_ascii("&"), from_ascii("$$amp!")); + // Then, we temporarily make all " and " strings to ampersands in order + // to handle them later on a per-char level. + iname = subst(iname, from_ascii(" and "), from_ascii(" & ")); + // Now we traverse through the string and replace the "&" by the proper + // output in- and outside groups + docstring name; + int gl = 0; + docstring::const_iterator p = iname.begin(); + while (p != iname.end()) { + // count grouping level + if (*p == '{') + ++gl; + else if (*p == '}') + --gl; + // generate string with probable placeholders + if (*p == '&') { + if (gl > 0) + // Inside groups, we output "and" + name += from_ascii("and"); + else + // Outside groups, we output a separator + name += from_ascii("$$namesep!"); + } + else + name += *p; + ++p; + } + + // re-insert the literal ampersands + name = subst(name, from_ascii("$$amp!"), from_ascii("&")); + + // Now construct the actual vector + return getVectorFromString(name, from_ascii(" $$namesep! ")); +} + + +bool multipleAuthors(docstring const author) +{ + return getAuthors(author).size() > 1; +} + + // converts a string containing LaTeX commands into unicode // for display. docstring convertLaTeXCommands(docstring const & str) @@ -105,7 +329,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 @@ -115,7 +339,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); @@ -156,7 +380,18 @@ docstring convertLaTeXCommands(docstring const & str) continue; } - // we just ignore braces + // Change text mode accents in the form + // {\v a} to \v{a} (see #9340). + // FIXME: This is a sort of mini-tex2lyx. + // Use the real tex2lyx instead! + static lyx::regex const tma_reg("^\\{\\\\[bcCdfGhHkrtuUv]\\s\\w\\}"); + if (lyx::regex_search(to_utf8(val), tma_reg)) { + val = val.substr(1); + val.replace(2, 1, from_ascii("{")); + continue; + } + + // Apart from the above, we just ignore braces if (ch == '{' || ch == '}') { val = val.substr(1); continue; @@ -175,14 +410,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; @@ -197,7 +435,50 @@ docstring convertLaTeXCommands(docstring const & str) return ret; } -} // anon namespace + +// 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; +} + +} // namespace ////////////////////////////////////////////////////////////////////// @@ -212,8 +493,26 @@ BibTeXInfo::BibTeXInfo(docstring const & key, docstring const & type) {} -docstring const BibTeXInfo::getAbbreviatedAuthor() const + +docstring const BibTeXInfo::getAuthorOrEditorList(Buffer const * buf, + bool full, bool forceshort) const { + docstring author = operator[]("author"); + if (author.empty()) + author = operator[]("editor"); + + return getAuthorList(buf, author, full, forceshort); +} + + +docstring const BibTeXInfo::getAuthorList(Buffer const * buf, + docstring const & author, bool const full, bool const forceshort, + bool const allnames, bool const beginning) const +{ + // Maxnames treshold depend on engine + size_t maxnames = buf ? + buf->params().documentClass().max_citenames() : 2; + if (!is_bibtex_) { docstring const opt = label(); if (opt.empty()) @@ -222,42 +521,114 @@ 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; } - docstring author = convertLaTeXCommands(operator[]("author")); - if (author.empty()) { - author = convertLaTeXCommands(operator[]("editor")); - if (author.empty()) - return bib_key_; - } + if (author.empty()) + 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 ")); + // Try to split the author list + vector const authors = getAuthors(author); - if (authors.size() == 2) - return bformat(_("%1$s and %2$s"), - familyName(authors[0]), familyName(authors[1])); + docstring retval; - if (authors.size() > 2) - return bformat(_("%1$s et al."), familyName(authors[0])); + CiteEngineType const engine_type = buf ? buf->params().citeEngineType() + : ENGINE_TYPE_DEFAULT; + + // These are defined in the styles + string const etal = + buf ? buf->params().documentClass().getCiteMacro(engine_type, "B_etal") + : " et al."; + string const namesep = + buf ? buf->params().documentClass().getCiteMacro(engine_type, "B_namesep") + : ", "; + string const lastnamesep = + buf ? buf->params().documentClass().getCiteMacro(engine_type, "B_lastnamesep") + : ", and "; + string const pairnamesep = + buf ? buf->params().documentClass().getCiteMacro(engine_type, "B_pairnamesep") + : " and "; + string firstnameform = + buf ? buf->params().documentClass().getCiteMacro(engine_type, "!firstnameform") + : "{%prefix%[[%prefix% ]]}%surname%{%suffix%[[, %suffix%]]}{%prename%[[, %prename%]]}"; + if (!beginning) + firstnameform = buf ? buf->params().documentClass().getCiteMacro(engine_type, "!firstbynameform") + : "%prename% {%prefix%[[%prefix% ]]}%surname%{%suffix%[[, %suffix%]]}"; + string othernameform = buf ? buf->params().documentClass().getCiteMacro(engine_type, "!othernameform") + : "{%prefix%[[%prefix% ]]}%surname%{%suffix%[[, %suffix%]]}{%prename%[[, %prename%]]}"; + if (!beginning) + othernameform = buf ? buf->params().documentClass().getCiteMacro(engine_type, "!otherbynameform") + : "%prename% {%prefix%[[%prefix% ]]}%surname%{%suffix%[[, %suffix%]]}"; + string citenameform = buf ? buf->params().documentClass().getCiteMacro(engine_type, "!citenameform") + : "{%prefix%[[%prefix% ]]}%surname%"; + + // Shorten the list (with et al.) if forceshort is set + // and the list can actually be shortened, else if maxcitenames + // is passed and full is not set. + bool shorten = forceshort && authors.size() > 1; + vector::const_iterator it = authors.begin(); + vector::const_iterator en = authors.end(); + for (size_t i = 0; it != en; ++it, ++i) { + if (i >= maxnames && !full) { + shorten = true; + break; + } + if (*it == "others") { + retval += buf ? buf->B_(etal) : from_ascii(etal); + break; + } + if (i > 0 && i == authors.size() - 1) { + if (authors.size() == 2) + retval += buf ? buf->B_(pairnamesep) : from_ascii(pairnamesep); + else + retval += buf ? buf->B_(lastnamesep) : from_ascii(lastnamesep); + } else if (i > 0) + retval += buf ? buf->B_(namesep) : from_ascii(namesep); + if (allnames) + retval += (i == 0) ? constructName(*it, firstnameform) + : constructName(*it, othernameform); + else + retval += constructName(*it, citenameform); + } + if (shorten) { + if (allnames) + retval = constructName(authors[0], firstnameform) + (buf ? buf->B_(etal) : from_ascii(etal)); + else + retval = constructName(authors[0], citenameform) + (buf ? buf->B_(etal) : from_ascii(etal)); + } - return familyName(authors[0]); + return convertLaTeXCommands(retval); } docstring const BibTeXInfo::getYear() const { - if (is_bibtex_) - return operator[]("year"); + if (is_bibtex_) { + // first try legacy year field + docstring year = operator[]("year"); + if (!year.empty()) + return year; + // now try biblatex's date field + year = operator[]("date"); + // Format is [-]YYYY-MM-DD*/[-]YYYY-MM-DD* + // We only want the years. + static regex const yreg("[-]?([\\d]{4}).*"); + static regex const ereg(".*/[-]?([\\d]{4}).*"); + smatch sm; + string const date = to_utf8(year); + if (!regex_match(date, sm, yreg)) + // cannot parse year. + return docstring(); + year = from_ascii(sm[1]); + // check for an endyear + if (regex_match(date, sm, ereg)) + year += char_type(0x2013) + from_ascii(sm[1]); + return year; + } docstring const opt = label(); if (opt.empty()) @@ -265,7 +636,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; @@ -274,171 +645,194 @@ docstring const BibTeXInfo::getYear() const } -docstring const BibTeXInfo::getXRef() const +namespace { + +docstring parseOptions(docstring const & format, string & optkey, + docstring & ifpart, docstring & 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. +docstring parseEmbeddedOption(docstring const & format, docstring & ifelsepart) { - if (!is_bibtex_) - return docstring(); - return operator[]("crossref"); + LASSERT(format[0] == '{' && format[1] == '%', return format); + string optkey; + docstring ifpart; + docstring elsepart; + docstring 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 = docstring(); return format; }); + ifelsepart = format.substr(0, format.size() - rest.size()); + return rest; } -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; +// 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. +docstring getClause(docstring const & format, docstring & clause) +{ + docstring 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; } - 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.size()) { - 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] == '%') { + docstring part; + docstring 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. +docstring parseOptions(docstring const & format, string & optkey, + docstring & ifpart, docstring & elsepart) +{ + LASSERT(format[0] == '{' && format[1] == '%', return format); + // strip '{%' + docstring 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 = to_utf8(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; - } + docstring 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); -} -} // anon namespace + // 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); +} -docstring BibTeXInfo::expandFormat(string const & format, - BibTeXInfo const * const xref, int & counter, Buffer const & buf, - bool richtext) const +} // namespace + +/* FIXME +Bug #9131 revealed an oddity in how we are generating citation information +when more than one key is given. We end up building a longer and longer format +string as we go, which we then have to re-parse, over and over and over again, +rather than generating the information for the individual keys and then putting +all of that together. We do that to deal with the way separators work, from what +I can tell, but it still feels like a hack. Fixing this would require quite a +bit of work, however. +*/ +docstring BibTeXInfo::expandFormat(docstring const & format, + BibTeXInfoList const xrefs, int & counter, Buffer const & buf, + CiteItem const & ci, bool next, bool second) const { // incorrect use of macros could put us in an infinite loop - static int max_passes = 5000; - docstring ret; // return value + static int const max_passes = 5000; + // the use of overly large keys can lead to performance problems, due + // to eventual attempts to convert LaTeX macros to unicode. See bug + // #8944. By default, the size is limited to 128 (in CiteItem), but + // for specific purposes (such as XHTML export), it needs to be enlarged + // This is perhaps not the best solution, but it will have to do for now. + size_t const max_keysize = ci.max_key_size; + odocstringstream ret; // return value string key; bool scanning_key = false; bool scanning_rich = false; - string fmt = format; - // we'll remove characters from the front of fmt as we + CiteEngineType const engine_type = buf.params().citeEngineType(); + docstring fmt = format; + // we'll remove characters from the front of fmt as we // deal with them - while (fmt.size()) { - if (counter++ > max_passes) { - LYXERR0("Recursion limit reached while parsing `" + 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[0] == '!') { // macro - string const val = - buf.params().documentClass().getCiteMacro(key); - fmt = val + fmt.substr(1); + string const val = + buf.params().documentClass().getCiteMacro(engine_type, key); + fmt = from_utf8(val) + fmt.substr(1); + counter += 1; continue; - } else if (key[0] == '_') { - // a translatable bit - string const val = - buf.params().documentClass().getCiteMacro(key); - docstring const trans = + } else if (prefixIs(key, "B_")) { + // a translatable bit (to the Buffer language) + string const val = + buf.params().documentClass().getCiteMacro(engine_type, key); + docstring const trans = translateIfPossible(from_utf8(val), buf.params().language->code()); - ret += trans; + ret << trans; + } else if (key[0] == '_') { + // a translatable bit (to the GUI language) + string const val = + buf.params().documentClass().getCiteMacro(engine_type, key); + docstring const trans = + translateIfPossible(from_utf8(val)); + ret << trans; } else { - docstring const val = getValueForKey(key, xref); - ret += val; + docstring const val = + getValueForKey(key, buf, ci, xrefs, max_keysize); + if (!scanning_rich) + ret << from_ascii("{!!}"); + ret << val; + if (!scanning_rich) + ret << from_ascii("{!!}"); } } else { // beginning of key @@ -446,7 +840,7 @@ docstring BibTeXInfo::expandFormat(string const & format, scanning_key = true; } } - else if (thischar == '{') { + else if (thischar == '{') { // beginning of option? if (scanning_key) { LYXERR0("ERROR: Found `{' when scanning key in `" << format << "'."); @@ -456,45 +850,62 @@ docstring BibTeXInfo::expandFormat(string const & format, if (fmt[1] == '%') { // it is the beginning of an optional format string optkey; - string ifpart; - string elsepart; - string const newfmt = + docstring ifpart; + docstring elsepart; + docstring 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, counter, buf, richtext); - else if (!elsepart.empty()) - ret += expandFormat(elsepart, xref, counter, buf, richtext); + docstring const val = + getValueForKey(optkey, buf, ci, xrefs); + if (optkey == "next" && next) + ret << ifpart; // without expansion + else if (optkey == "second" && second) { + int newcounter = 0; + ret << expandFormat(ifpart, xrefs, newcounter, buf, + ci, next); + } else if (!val.empty()) { + int newcounter = 0; + ret << expandFormat(ifpart, xrefs, newcounter, buf, + ci, next); + } else if (!elsepart.empty()) { + int newcounter = 0; + ret << expandFormat(elsepart, xrefs, newcounter, buf, + ci, 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 '{' was not followed by % or !. + // we are here if '{' was not followed by % or !. // So it's just a character. - ret += thischar; + 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) - ret += thischar; - // else the character is discarded, which will happen only if - // richtext == false and we are scanning rich text + else { + try { + ret.put(thischar); + } catch (EncodingException & /* e */) { + LYXERR0("Uncodable character '" << docstring(1, thischar) << " in citation label!"); + } + } fmt = fmt.substr(1); } // for loop if (scanning_key) { @@ -505,15 +916,19 @@ docstring BibTeXInfo::expandFormat(string const & format, LYXERR0("Never found end of rich text in `" << format << "'!"); return _("ERROR!"); } - return ret; + return ret.str(); } -docstring const & BibTeXInfo::getInfo(BibTeXInfo const * const xref, - Buffer const & buf, bool richtext) const +docstring const & BibTeXInfo::getInfo(BibTeXInfoList const xrefs, + Buffer const & buf, CiteItem const & ci) const { - if (!info_.empty()) + bool const richtext = ci.richtext; + + 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")); @@ -521,17 +936,47 @@ docstring const & BibTeXInfo::getInfo(BibTeXInfo const * const xref, return info_; } + CiteEngineType const engine_type = buf.params().citeEngineType(); DocumentClass const & dc = buf.params().documentClass(); - string const & format = dc.getCiteFormat(to_utf8(entry_type_)); + docstring const & format = + from_utf8(dc.getCiteFormat(engine_type, to_utf8(entry_type_))); int counter = 0; - info_ = expandFormat(format, xref, counter, buf, richtext); + info_ = expandFormat(format, xrefs, counter, buf, + ci, false, false); + + if (info_.empty()) { + // this probably shouldn't happen + return info_; + } + + if (richtext) { + info_richtext_ = convertLaTeXCommands(processRichtext(info_, true)); + return info_richtext_; + } - if (!info_.empty()) - info_ = convertLaTeXCommands(info_); + info_ = convertLaTeXCommands(processRichtext(info_, false)); return info_; } +docstring const BibTeXInfo::getLabel(BibTeXInfoList const xrefs, + Buffer const & buf, docstring const & format, + CiteItem const & ci, bool next, bool second) const +{ + docstring loclabel; + + int counter = 0; + loclabel = expandFormat(format, xrefs, counter, buf, ci, next, second); + + if (!loclabel.empty() && !next) { + loclabel = processRichtext(loclabel, ci.richtext); + loclabel = convertLaTeXCommands(loclabel); + } + + return loclabel; +} + + docstring const & BibTeXInfo::operator[](docstring const & field) const { BibTeXInfo::const_iterator it = find(field); @@ -540,21 +985,158 @@ 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 & oldkey, Buffer const & buf, + CiteItem const & ci, BibTeXInfoList const xrefs, size_t maxsize) const { - docstring const ret = operator[](key); - if (!ret.empty() || !xref) - return ret; - return (*xref)[key]; + // anything less is pointless + LASSERT(maxsize >= 16, maxsize = 16); + string key = oldkey; + bool cleanit = false; + if (prefixIs(oldkey, "clean:")) { + key = oldkey.substr(6); + cleanit = true; + } + + docstring ret = operator[](key); + if (ret.empty() && !xrefs.empty()) { + vector::const_iterator it = xrefs.begin(); + vector::const_iterator en = xrefs.end(); + for (; it != en; ++it) { + if (*it && !(**it)[key].empty()) { + ret = (**it)[key]; + break; + } + } + } + if (ret.empty()) { + // some special keys + // FIXME: dialog, textbefore and textafter have nothing to do with this + if (key == "dialog" && ci.context == CiteItem::Dialog) + ret = from_ascii("x"); // any non-empty string will do + else if (key == "export" && ci.context == CiteItem::Export) + ret = from_ascii("x"); // any non-empty string will do + else if (key == "ifstar" && ci.Starred) + ret = from_ascii("x"); // any non-empty string will do + else if (key == "ifqualified" && ci.isQualified) + ret = from_ascii("x"); // any non-empty string will do + else if (key == "entrytype") + ret = entry_type_; + else if (prefixIs(key, "ifentrytype:") + && from_ascii(key.substr(12)) == entry_type_) + ret = from_ascii("x"); // any non-empty string will do + else if (key == "key") + ret = bib_key_; + else if (key == "label") + ret = label_; + else if (key == "modifier" && modifier_ != 0) + ret = modifier_; + else if (key == "numericallabel") + ret = cite_number_; + else if (prefixIs(key, "ifmultiple:")) { + // Return whether we have multiple authors + docstring const kind = operator[](from_ascii(key.substr(11))); + if (multipleAuthors(kind)) + ret = from_ascii("x"); // any non-empty string will do + } + else if (prefixIs(key, "abbrvnames:")) { + // Special key to provide abbreviated name list, + // with respect to maxcitenames. Suitable for Bibliography + // beginnings. + docstring const kind = operator[](from_ascii(key.substr(11))); + ret = getAuthorList(&buf, kind, false, false, true); + if (ci.forceUpperCase && isLowerCase(ret[0])) + ret[0] = uppercase(ret[0]); + } else if (prefixIs(key, "fullnames:")) { + // Return a full name list. Suitable for Bibliography + // beginnings. + docstring const kind = operator[](from_ascii(key.substr(10))); + ret = getAuthorList(&buf, kind, true, false, true); + if (ci.forceUpperCase && isLowerCase(ret[0])) + ret[0] = uppercase(ret[0]); + } else if (prefixIs(key, "forceabbrvnames:")) { + // Special key to provide abbreviated name lists, + // irrespective of maxcitenames. Suitable for Bibliography + // beginnings. + docstring const kind = operator[](from_ascii(key.substr(15))); + ret = getAuthorList(&buf, kind, false, true, true); + if (ci.forceUpperCase && isLowerCase(ret[0])) + ret[0] = uppercase(ret[0]); + } else if (prefixIs(key, "abbrvbynames:")) { + // Special key to provide abbreviated name list, + // with respect to maxcitenames. Suitable for further names inside a + // bibliography item // (such as "ed. by ...") + docstring const kind = operator[](from_ascii(key.substr(11))); + ret = getAuthorList(&buf, kind, false, false, true, false); + if (ci.forceUpperCase && isLowerCase(ret[0])) + ret[0] = uppercase(ret[0]); + } else if (prefixIs(key, "fullbynames:")) { + // Return a full name list. Suitable for further names inside a + // bibliography item // (such as "ed. by ...") + docstring const kind = operator[](from_ascii(key.substr(10))); + ret = getAuthorList(&buf, kind, true, false, true, false); + if (ci.forceUpperCase && isLowerCase(ret[0])) + ret[0] = uppercase(ret[0]); + } else if (prefixIs(key, "forceabbrvbynames:")) { + // Special key to provide abbreviated name lists, + // irrespective of maxcitenames. Suitable for further names inside a + // bibliography item // (such as "ed. by ...") + docstring const kind = operator[](from_ascii(key.substr(15))); + ret = getAuthorList(&buf, kind, false, true, true, false); + if (ci.forceUpperCase && isLowerCase(ret[0])) + ret[0] = uppercase(ret[0]); + } else if (key == "abbrvciteauthor") { + // Special key to provide abbreviated author or + // editor names (suitable for citation labels), + // with respect to maxcitenames. + ret = getAuthorOrEditorList(&buf, false, false); + if (ci.forceUpperCase && isLowerCase(ret[0])) + ret[0] = uppercase(ret[0]); + } else if (key == "fullciteauthor") { + // Return a full author or editor list (for citation labels) + ret = getAuthorOrEditorList(&buf, true, false); + if (ci.forceUpperCase && isLowerCase(ret[0])) + ret[0] = uppercase(ret[0]); + } else if (key == "forceabbrvciteauthor") { + // Special key to provide abbreviated author or + // editor names (suitable for citation labels), + // irrespective of maxcitenames. + ret = getAuthorOrEditorList(&buf, false, true); + if (ci.forceUpperCase && isLowerCase(ret[0])) + ret[0] = uppercase(ret[0]); + } 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(); + docstring const & format = + from_utf8(dc.getCiteFormat(engine_type, to_utf8(entry_type_), false)); + int counter = 0; + ret = expandFormat(format, xrefs, counter, buf, ci, false, false); + } else if (key == "textbefore") + ret = ci.textBefore; + else if (key == "textafter") + ret = ci.textAfter; + else if (key == "curpretext") + ret = ci.getPretexts()[bib_key_]; + else if (key == "curposttext") + ret = ci.getPosttexts()[bib_key_]; + else if (key == "year") + ret = getYear(); + } + + if (cleanit) + ret = html::cleanAttr(ret); + + // make sure it is not too big + support::truncateWithEllipsis(ret, maxsize); + return ret; } @@ -565,15 +1147,57 @@ 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 + + +vector const BiblioInfo::getXRefs(BibTeXInfo const & data, bool const nested) const +{ + vector result; + if (!data.isBibTeX()) + return result; + // Legacy crossref field. This is not nestable. + if (!nested && !data["crossref"].empty()) { + docstring const xrefkey = data["crossref"]; + result.push_back(xrefkey); + // However, check for nested xdatas + BiblioInfo::const_iterator it = find(xrefkey); + if (it != end()) { + BibTeXInfo const & xref = it->second; + vector const nxdata = getXRefs(xref, true); + if (!nxdata.empty()) + result.insert(result.end(), nxdata.begin(), nxdata.end()); + } + } + // Biblatex's xdata field. Infinitely nestable. + // XData field can consist of a comma-separated list of keys + vector const xdatakeys = getVectorFromString(data["xdata"]); + if (!xdatakeys.empty()) { + vector::const_iterator xit = xdatakeys.begin(); + vector::const_iterator xen = xdatakeys.end(); + for (; xit != xen; ++xit) { + docstring const xdatakey = *xit; + result.push_back(xdatakey); + BiblioInfo::const_iterator it = find(xdatakey); + if (it != end()) { + BibTeXInfo const & xdata = it->second; + vector const nxdata = getXRefs(xdata, true); + if (!nxdata.empty()) + result.insert(result.end(), nxdata.begin(), nxdata.end()); } - }; -} // namespace anon + } + } + return result; +} vector const BiblioInfo::getKeys() const @@ -611,13 +1235,13 @@ vector const BiblioInfo::getEntries() const } -docstring const BiblioInfo::getAbbreviatedAuthor(docstring const & key) const +docstring const BiblioInfo::getAuthorOrEditorList(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.getAuthorOrEditorList(&buf, false); } @@ -639,15 +1263,23 @@ docstring const BiblioInfo::getYear(docstring const & key, bool use_modifier) co BibTeXInfo const & data = it->second; docstring year = data.getYear(); if (year.empty()) { - // let's try the crossref - docstring const xref = data.getXRef(); - if (xref.empty()) - return _("No year"); // no luck - BiblioInfo::const_iterator const xrefit = find(xref); - if (xrefit == end()) - return _("No year"); // no luck again - BibTeXInfo const & xref_data = xrefit->second; - year = xref_data.getYear(); + // let's try the crossrefs + vector const xrefs = getXRefs(data); + if (xrefs.empty()) + // no luck + return docstring(); + vector::const_iterator it = xrefs.begin(); + vector::const_iterator en = xrefs.end(); + for (; it != en; ++it) { + BiblioInfo::const_iterator const xrefit = find(*it); + if (xrefit == end()) + continue; + BibTeXInfo const & xref_data = xrefit->second; + year = xref_data.getYear(); + if (!year.empty()) + // success! + break; + } } if (use_modifier && data.modifier() != 0) year += data.modifier(); @@ -655,188 +1287,139 @@ docstring const BiblioInfo::getYear(docstring const & key, bool use_modifier) co } -docstring const BiblioInfo::getInfo(docstring const & key, - Buffer const & buf, bool richtext) const +docstring const BiblioInfo::getYear(docstring const & key, Buffer const & buf, bool use_modifier) const { - BiblioInfo::const_iterator it = find(key); - if (it == end()) - return docstring(); - BibTeXInfo const & data = it->second; - BibTeXInfo const * xrefptr = 0; - docstring const xref = data.getXRef(); - if (!xref.empty()) { - BiblioInfo::const_iterator const xrefit = find(xref); - if (xrefit != end()) - xrefptr = &(xrefit->second); - } - return data.getInfo(xrefptr, buf, richtext); + docstring const year = getYear(key, use_modifier); + if (year.empty()) + return buf.B_("No year"); + return year; } -bool BiblioInfo::isBibtex(docstring const & key) const +docstring const BiblioInfo::getInfo(docstring const & key, + Buffer const & buf, CiteItem const & ci) const { BiblioInfo::const_iterator it = find(key); if (it == end()) - return false; - return it->second.isBibTeX(); -} - - - -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); + return docstring(_("Bibliography entry not found!")); + BibTeXInfo const & data = it->second; + BibTeXInfoList xrefptrs; + vector const xrefs = getXRefs(data); + if (!xrefs.empty()) { + vector::const_iterator it = xrefs.begin(); + vector::const_iterator en = xrefs.end(); + for (; it != en; ++it) { + BiblioInfo::const_iterator const xrefit = find(*it); + if (xrefit != end()) + xrefptrs.push_back(&(xrefit->second)); + } + } + return data.getInfo(xrefptrs, buf, ci); } -vector const BiblioInfo::getNumericalStrings( - docstring const & key, Buffer const & buf) const +docstring const BiblioInfo::getLabel(vector keys, + Buffer const & buf, string const & style, CiteItem const & ci) 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: - 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; + size_t max_size = ci.max_size; + // shorter makes no sense + LASSERT(max_size >= 16, max_size = 16); - case CITEALP: - str = from_ascii("#ID"); - break; + // we can't display more than 10 of these, anyway + bool const too_many_keys = keys.size() > 10; + if (too_many_keys) + keys.resize(10); - case CITEAUTHOR: - str = author; - break; - - case CITEYEAR: - str = year; - break; - - case CITEYEARPAR: - str = '(' + year + ')'; - break; + CiteEngineType const engine_type = buf.params().citeEngineType(); + DocumentClass const & dc = buf.params().documentClass(); + docstring const & format = from_utf8(dc.getCiteFormat(engine_type, style, false, "cite")); + docstring ret = format; + vector::const_iterator key = keys.begin(); + vector::const_iterator ken = keys.end(); + for (int i = 0; key != ken; ++key, ++i) { + BiblioInfo::const_iterator it = find(*key); + BibTeXInfo empty_data; + empty_data.key(*key); + BibTeXInfo & data = empty_data; + vector xrefptrs; + if (it != end()) { + data = it->second; + vector const xrefs = getXRefs(data); + if (!xrefs.empty()) { + vector::const_iterator it = xrefs.begin(); + vector::const_iterator en = xrefs.end(); + for (; it != en; ++it) { + BiblioInfo::const_iterator const xrefit = find(*it); + if (xrefit != end()) + xrefptrs.push_back(&(xrefit->second)); + } + } } - - vec[i] = str; + ret = data.getLabel(xrefptrs, buf, ret, ci, key + 1 != ken, i == 1); } - return vec; + if (too_many_keys) + ret.push_back(0x2026);//HORIZONTAL ELLIPSIS + support::truncateWithEllipsis(ret, max_size); + return ret; } -vector const BiblioInfo::getAuthorYearStrings( - docstring const & key, Buffer const & buf) const +bool BiblioInfo::isBibtex(docstring const & key) 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; + docstring key1; + split(key, key1, ','); + BiblioInfo::const_iterator it = find(key1); + if (it == end()) + return false; + return it->second.isBibTeX(); +} - case CITEAUTHOR: - str = author; - break; - case CITEYEAR: - str = year; - break; +BiblioInfo::CiteStringMap const BiblioInfo::getCiteStrings( + vector const & keys, vector const & styles, + Buffer const & buf, CiteItem const & ci) const +{ + if (empty()) + return vector>(); - case CITEYEARPAR: - str = '(' + year + ')'; - break; - } - vec[i] = str; + string style; + CiteStringMap csm(styles.size()); + for (size_t i = 0; i != csm.size(); ++i) { + style = styles[i].name; + csm[i] = make_pair(from_ascii(style), getLabel(keys, buf, style, ci)); } - return vec; + + return csm; } 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->getAuthorOrEditorList(); + docstring const rauth = rhs->getAuthorOrEditorList(); + 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); } +} // namespace + void BiblioInfo::collectCitedEntries(Buffer const & buf) { @@ -846,9 +1429,9 @@ void BiblioInfo::collectCitedEntries(Buffer const & buf) // FIXME We may want to collect these differently, in the first case, // so that we might have them in order of appearance. set citekeys; - Toc const & toc = buf.tocBackend().toc("citation"); - Toc::const_iterator it = toc.begin(); - Toc::const_iterator const en = toc.end(); + shared_ptr toc = buf.tocBackend().toc("citation"); + Toc::const_iterator it = toc->begin(); + Toc::const_iterator const en = toc->end(); for (; it != en; ++it) { if (it->str().empty()) continue; @@ -857,9 +1440,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(); @@ -872,7 +1455,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(); @@ -884,16 +1467,15 @@ 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; // used to remember the last one we saw // we'll be comparing entries to see if we need to add // modifiers, like "1984a" - map::iterator last; + map::iterator last = bimap_.end(); vector::const_iterator it = cited_entries_.begin(); vector::const_iterator const en = cited_entries_.end(); @@ -908,8 +1490,11 @@ void BiblioInfo::makeCitationLabels(Buffer const & buf) docstring const num = convert(++keynumber); entry.setCiteNumber(num); } else { - if (it != cited_entries_.begin() - && entry.getAbbreviatedAuthor() == last->second.getAbbreviatedAuthor() + // The first test here is checking whether this is the first + // time through the loop. If so, then we do not have anything + // with which to compare. + if (last != bimap_.end() + && entry.getAuthorOrEditorList() == last->second.getAuthorOrEditorList() // we access the year via getYear() so as to get it from the xref, // if we need to do so && getYear(entry.key()) == getYear(last->second.key())) { @@ -924,11 +1509,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.getAuthorOrEditorList(&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()); + } + } } @@ -938,114 +1545,41 @@ 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 citationStyleFromString(string const & command, + BufferParams const & params) { - CitationStyle s; + CitationStyle cs; if (command.empty()) - return s; + return cs; - string cmd = command; - if (cmd[0] == 'C') { - s.forceUpperCase = true; - cmd[0] = 'c'; + string const alias = params.getCiteAlias(command); + string cmd = alias.empty() ? command : alias; + if (isUpperCase(command[0])) { + cs.forceUpperCase = true; + cmd[0] = lowercase(cmd[0]); } - size_t const n = cmd.size() - 1; - if (cmd != "cite" && cmd[n] == '*') { - s.full = true; - cmd = cmd.substr(0, n); + size_t const n = command.size() - 1; + if (command[n] == '*') { + cs.hasStarredVersion = true; + if (suffixIs(cmd, '*')) + cmd = cmd.substr(0, cmd.size() - 1); } - 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.name = 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, bool const latex) { - 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 = latex ? cs.cmd : cs.name; + if (cs.forceUpperCase) + cmd[0] = uppercase(cmd[0]); + if (cs.hasStarredVersion) + cmd += '*'; + return cmd; } } // namespace lyx -