X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBiblioInfo.cpp;h=66fcd39fe1bb1952a1fd62ee241662f1451fbea5;hb=bb80bd78f981c888efcc030168bd4e366b0ca6cd;hp=8f8523315d65d4b130eaf328c341091a5009f005;hpb=4e142856d7607a54e67d726221dd0a3ff09cc5ea;p=lyx.git diff --git a/src/BiblioInfo.cpp b/src/BiblioInfo.cpp index 8f8523315d..66fcd39fe1 100644 --- a/src/BiblioInfo.cpp +++ b/src/BiblioInfo.cpp @@ -4,7 +4,7 @@ * Licence details can be found in the file COPYING. * * \author Angus Leeming - * \author Herbert Voß + * \author Herbert Voß * \author Richard Heck * * Full author contact details are available in file CREDITS. @@ -16,6 +16,7 @@ #include "Buffer.h" #include "BufferParams.h" #include "buffer_funcs.h" +#include "Encoding.h" #include "InsetIterator.h" #include "Paragraph.h" @@ -24,10 +25,11 @@ #include "insets/InsetBibtex.h" #include "insets/InsetInclude.h" -#include "support/lassert.h" #include "support/docstream.h" #include "support/gettext.h" +#include "support/lassert.h" #include "support/lstrings.h" +#include "support/textutils.h" #include "boost/regex.hpp" @@ -37,6 +39,160 @@ using namespace lyx::support; namespace lyx { +namespace { + +// gets the "family name" from an author-type string +docstring familyName(docstring const & name) +{ + if (name.empty()) + return docstring(); + + // 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 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(); + + // Now we look for the first token that begins with a lower case letter. + vector::const_iterator it = pieces.begin(); + vector::const_iterator en = pieces.end(); + for (; it != en; ++it) { + if ((*it).size() == 0) + continue; + char_type const c = (*it)[0]; + if (isLower(c)) + break; + } + + if (it == en) // we never found a "von" + return pieces.back(); + + // reconstruct what we need to return + docstring retval; + bool first = true; + for (; it != en; ++it) { + if (!first) + retval += " "; + else + first = false; + retval += *it; + } + return retval; +} + +// converts a string containing LaTeX commands into unicode +// for display. +docstring convertLaTeXCommands(docstring const & str) +{ + docstring val = str; + docstring ret; + + bool scanning_cmd = false; + bool scanning_math = false; + bool escaped = false; // used to catch \$, etc. + while (val.size()) { + char_type const ch = val[0]; + + // if we're scanning math, we output everything until we + // find an unescaped $, at which point we break out. + if (scanning_math) { + if (escaped) + escaped = false; + else if (ch == '\\') + escaped = true; + else if (ch == '$') + scanning_math = false; + ret += ch; + val = val.substr(1); + continue; + } + + // if we're scanning a command name, then we just + // discard characters until we hit something that + // isn't alpha. + if (scanning_cmd) { + if (isAlphaASCII(ch)) { + val = val.substr(1); + escaped = false; + continue; + } + // so we're done with this command. + // now we fall through and check this character. + scanning_cmd = false; + } + + // was the last character a \? If so, then this is something like: + // \\ or \$, so we'll just output it. That's probably not always right... + if (escaped) { + // exception: output \, as THIN SPACE + if (ch == ',') + ret.push_back(0x2009); + else + ret += ch; + val = val.substr(1); + escaped = false; + continue; + } + + if (ch == '$') { + ret += ch; + val = val.substr(1); + scanning_math = true; + continue; + } + + // we just ignore braces + if (ch == '{' || ch == '}') { + val = val.substr(1); + continue; + } + + // we're going to check things that look like commands, so if + // this doesn't, just output it. + if (ch != '\\') { + ret += ch; + val = val.substr(1); + continue; + } + + // ok, could be a command of some sort + // let's see if it corresponds to some unicode + // 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)) { + val.insert(3, from_ascii("}")); + val.insert(2, from_ascii("{")); + } + docstring rem; + docstring const cnvtd = Encodings::fromLaTeXCommand(val, rem, + Encodings::TEXT_CMD); + if (!cnvtd.empty()) { + // it did, so we'll take that bit and proceed with what's left + ret += cnvtd; + val = rem; + continue; + } + // it's a command of some sort + scanning_cmd = true; + escaped = true; + val = val.substr(1); + } + return ret; +} + +} // anon namespace + + ////////////////////////////////////////////////////////////////////// // // BibTeXInfo @@ -44,7 +200,7 @@ namespace lyx { ////////////////////////////////////////////////////////////////////// BibTeXInfo::BibTeXInfo(docstring const & key, docstring const & type) - : is_bibtex_(true), bib_key_(key), entry_type_(type) + : is_bibtex_(true), bib_key_(key), entry_type_(type), info_() {} @@ -54,57 +210,21 @@ bool BibTeXInfo::hasField(docstring const & field) const } -docstring const & BibTeXInfo::getValueForField(docstring const & field) const -{ - BibTeXInfo::const_iterator it = find(field); - if (it != end()) - return it->second; - static docstring const empty_value = docstring(); - return empty_value; -} - - -docstring const & BibTeXInfo::getValueForField(string const & field) const -{ - return getValueForField(from_ascii(field)); -} - - -docstring familyName(docstring const & name) +docstring const BibTeXInfo::getAbbreviatedAuthor() const { - if (name.empty()) - return docstring(); - - // Very simple parser - docstring fname = name; - - // possible authorname combinations are: - // "Surname, FirstName" - // "Surname, F." - // "FirstName Surname" - // "F. Surname" - docstring::size_type idx = fname.find(','); - if (idx != docstring::npos) - return ltrim(fname.substr(0, idx)); - idx = fname.rfind('.'); - if (idx != docstring::npos && idx + 1 < fname.size()) - fname = ltrim(fname.substr(idx + 1)); - // test if we have a LaTeX Space in front - if (fname[0] == '\\') - return fname.substr(2); - return rtrim(fname); -} + if (!is_bibtex_) { + docstring const opt = label(); + if (opt.empty()) + return docstring(); + docstring authors; + split(opt, authors, '('); + return authors; + } -docstring const BibTeXInfo::getAbbreviatedAuthor() const -{ - if (!is_bibtex_) - return docstring(); - - docstring author = getValueForField("author"); - + docstring author = convertLaTeXCommands(operator[]("author")); if (author.empty()) { - author = getValueForField("editor"); + author = convertLaTeXCommands(operator[]("editor")); if (author.empty()) return bib_key_; } @@ -113,7 +233,7 @@ docstring const BibTeXInfo::getAbbreviatedAuthor() const // 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"), familyName(authors[0]), familyName(authors[1])); @@ -127,53 +247,70 @@ docstring const BibTeXInfo::getAbbreviatedAuthor() const docstring const BibTeXInfo::getYear() const { - if (!is_bibtex_) + if (is_bibtex_) + return operator[]("year"); + + docstring const opt = label(); + if (opt.empty()) return docstring(); - - docstring year = getValueForField("year"); - if (year.empty()) - year = _("No year"); + + docstring authors; + docstring const tmp = split(opt, authors, '('); + docstring year; + split(tmp, year, ')'); return year; } -docstring const BibTeXInfo::getInfo() const +docstring const BibTeXInfo::getXRef() const +{ + if (!is_bibtex_) + return docstring(); + return operator[]("crossref"); +} + + +docstring const & BibTeXInfo::getInfo(BibTeXInfo const * const xref) const { + if (!info_.empty()) + return info_; + if (!is_bibtex_) { BibTeXInfo::const_iterator it = find(from_ascii("ref")); - return it->second; + info_ = it->second; + return info_; } // FIXME - // This could be made a lot better using the entryType + // This could be made a lot better using the entry_type_ // field to customize the output based upon entry type. // Search for all possible "required" fields - docstring author = getValueForField("author"); + docstring author = getValueForKey("author", xref); if (author.empty()) - author = getValueForField("editor"); + author = getValueForKey("editor", xref); - docstring year = getValueForField("year"); - docstring title = getValueForField("title"); - docstring docLoc = getValueForField("pages"); + docstring year = getValueForKey("year", xref); + docstring title = getValueForKey("title", xref); + docstring docLoc = getValueForKey("pages", xref); if (docLoc.empty()) { - docLoc = getValueForField("chapter"); + docLoc = getValueForKey("chapter", xref); if (!docLoc.empty()) - docLoc = from_ascii("Ch. ") + docLoc; + docLoc = _("Ch. ") + docLoc; } else { - docLoc = from_ascii("pp. ") + docLoc; + docLoc = _("pp. ") + docLoc; } - docstring media = getValueForField("journal"); + docstring media = getValueForKey("journal", xref); if (media.empty()) { - media = getValueForField("publisher"); + media = getValueForKey("publisher", xref); if (media.empty()) { - media = getValueForField("school"); + media = getValueForKey("school", xref); if (media.empty()) - media = getValueForField("institution"); + media = getValueForKey("institution"); } } - docstring volume = getValueForField("volume"); + docstring volume = getValueForKey("volume", xref); odocstringstream result; if (!author.empty()) @@ -183,16 +320,45 @@ docstring const BibTeXInfo::getInfo() const if (!media.empty()) result << ", " << media; if (!year.empty()) - result << ", " << year; + result << " (" << year << ")"; if (!docLoc.empty()) result << ", " << docLoc; docstring const result_str = rtrim(result.str()); - if (!result_str.empty()) - return result_str; + if (!result_str.empty()) { + info_ = convertLaTeXCommands(result_str); + return info_; + } // This should never happen (or at least be very unusual!) - return docstring(); + static docstring e = docstring(); + return e; +} + + +docstring const & BibTeXInfo::operator[](docstring const & field) const +{ + BibTeXInfo::const_iterator it = find(field); + if (it != end()) + return it->second; + 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 const ret = operator[](key); + if (!ret.empty() || !xref) + return ret; + return (*xref)[key]; } @@ -265,6 +431,18 @@ docstring const BiblioInfo::getYear(docstring const & key) const if (it == end()) return docstring(); BibTeXInfo const & data = it->second; + docstring year = data.getYear(); + if (!year.empty()) + return year; + // 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; + return xref_data.getYear(); return data.getYear(); } @@ -275,7 +453,14 @@ docstring const BiblioInfo::getInfo(docstring const & key) const if (it == end()) return docstring(); BibTeXInfo const & data = it->second; - return data.getInfo(); + 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); } @@ -427,8 +612,8 @@ namespace { char const * const citeCommands[] = { - "cite", "nocite", "citet", "citep", "citealt", "citealp", - "citeauthor", "citeyear", "citeyearpar" }; + "cite", "citet", "citep", "citealt", "citealp", + "citeauthor", "citeyear", "citeyearpar", "nocite" }; unsigned int const nCiteCommands = sizeof(citeCommands) / sizeof(char *); @@ -489,13 +674,13 @@ string citationStyleToString(const CitationStyle & s) string cite = citeCommands[s.style]; if (s.full) { CiteStyle const * last = citeStylesFull + nCiteStylesFull; - if (find(citeStylesFull, last, s.style) != last) + if (std::find(citeStylesFull, last, s.style) != last) cite += '*'; } if (s.forceUpperCase) { CiteStyle const * last = citeStylesUCase + nCiteStylesUCase; - if (find(citeStylesUCase, last, s.style) != last) + if (std::find(citeStylesUCase, last, s.style) != last) cite[0] = 'C'; }