X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBiblioInfo.cpp;h=bb9b27f7feab4b11993cedc35dcd0454ee5df9cd;hb=2098f1d8c20d51e63e670bcdc9da8996068975bf;hp=6118dde26d4ceff2f92c47b7c735f5936fb48d3e;hpb=bd8a0686fb359ef71aebed88d11f969ca8157db1;p=lyx.git diff --git a/src/BiblioInfo.cpp b/src/BiblioInfo.cpp index 6118dde26d..bb9b27f7fe 100644 --- a/src/BiblioInfo.cpp +++ b/src/BiblioInfo.cpp @@ -19,12 +19,14 @@ #include "Encoding.h" #include "InsetIterator.h" #include "Paragraph.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/docstream.h" #include "support/gettext.h" #include "support/lassert.h" @@ -33,55 +35,17 @@ #include "boost/regex.hpp" +#include + using namespace std; using namespace lyx::support; namespace lyx { -////////////////////////////////////////////////////////////////////// -// -// BibTeXInfo -// -////////////////////////////////////////////////////////////////////// - -BibTeXInfo::BibTeXInfo(docstring const & key, docstring const & type) - : is_bibtex_(true), bib_key_(key), entry_type_(type), info_() -{} - - -bool BibTeXInfo::hasField(docstring const & field) const -{ - return count(field) == 1; -} - - -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]; -} - +namespace { +// gets the "family name" from an author-type string docstring familyName(docstring const & name) { if (name.empty()) @@ -128,10 +92,132 @@ docstring familyName(docstring const & name) 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 +// +////////////////////////////////////////////////////////////////////// + +BibTeXInfo::BibTeXInfo(docstring const & key, docstring const & type) + : is_bibtex_(true), bib_key_(key), entry_type_(type), info_() +{} + + +bool BibTeXInfo::hasField(docstring const & field) const +{ + return count(field) == 1; +} + + docstring const BibTeXInfo::getAbbreviatedAuthor() const { if (!is_bibtex_) { - docstring const opt = trim(operator[]("label")); + docstring const opt = label(); if (opt.empty()) return docstring(); @@ -140,9 +226,9 @@ docstring const BibTeXInfo::getAbbreviatedAuthor() const return authors; } - docstring author = operator[]("author"); + docstring author = convertLaTeXCommands(operator[]("author")); if (author.empty()) { - author = operator[]("editor"); + author = convertLaTeXCommands(operator[]("editor")); if (author.empty()) return bib_key_; } @@ -168,7 +254,7 @@ docstring const BibTeXInfo::getYear() const if (is_bibtex_) return operator[]("year"); - docstring const opt = trim(operator[]("label")); + docstring const opt = label(); if (opt.empty()) return docstring(); @@ -188,106 +274,6 @@ docstring const BibTeXInfo::getXRef() const } -namespace { - - 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) { - 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); - 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 - - docstring const & BibTeXInfo::getInfo(BibTeXInfo const * const xref) const { if (!info_.empty()) @@ -354,6 +340,32 @@ docstring const & BibTeXInfo::getInfo(BibTeXInfo const * const xref) const } +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]; +} + + ////////////////////////////////////////////////////////////////////// // // BiblioInfo @@ -594,6 +606,78 @@ void BiblioInfo::mergeBiblioInfo(BiblioInfo const & info) } +namespace { + // used in xhtml to sort a list of BibTeXInfo objects + bool lSorter(BibTeXInfo const * lhs, BibTeXInfo const * rhs) + { + return lhs->getAbbreviatedAuthor() < rhs->getAbbreviatedAuthor(); + } +} + + +void BiblioInfo::collectCitedEntries(Buffer const & buf) +{ + cited_entries_.clear(); + // We are going to collect all the citation keys used in the document, + // getting them from the TOC. + // 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(); + for (; it != en; ++it) { + if (it->str().empty()) + continue; + vector const keys = getVectorFromString(it->str()); + citekeys.insert(keys.begin(), keys.end()); + } + 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 + // this document... + vector bi; + set::const_iterator cit = citekeys.begin(); + set::const_iterator const cen = citekeys.end(); + for (; cit != cen; ++cit) { + BiblioInfo::const_iterator const bt = find(*cit); + if (bt == end() || !bt->second.isBibTeX()) + continue; + bi.push_back(&(bt->second)); + } + // ...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(); + for (; bit != ben; ++bit) + cited_entries_.push_back((*bit)->key()); +} + + +void BiblioInfo::makeCitationLabels(Buffer const & buf) +{ + collectCitedEntries(buf); + // FIXME It'd be nice to do author-year as well as numerical + // and maybe even some other sorts of labels. + vector::const_iterator it = cited_entries_.begin(); + vector::const_iterator const en = cited_entries_.end(); + int keynumber = 0; + for (; it != en; ++it) { + map::iterator const biit = bimap_.find(*it); + // this shouldn't happen, but... + if (biit == bimap_.end()) + continue; + BibTeXInfo & entry = biit->second; + docstring const key = convert(++keynumber); + entry.setCiteKey(key); + } +} + + ////////////////////////////////////////////////////////////////////// // // CitationStyle @@ -666,13 +750,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'; }