* Licence details can be found in the file COPYING.
*
* \author Angus Leeming
- * \author Herbert Voss
+ * \author Herbert Voß
*
- * Full author contact details are available in file CREDITS
+ * Full author contact details are available in file CREDITS.
*/
#include <config.h>
-#ifdef __GNUG__
-#pragma implementation
-#endif
-
-#include "LString.h"
#include "biblio.h"
-#include "gettext.h" // for _()
-#include "helper_funcs.h"
+
+#include "buffer.h"
+#include "bufferparams.h"
+#include "gettext.h"
+
#include "support/lstrings.h"
-#include "support/LAssert.h"
#include <boost/regex.hpp>
#include <algorithm>
+#include <sstream>
+using std::string;
+using std::ostringstream;
using std::vector;
+
+namespace lyx {
+
+using support::ascii_lowercase;
+using support::bformat;
+using support::compare_ascii_no_case;
+using support::contains;
+using support::getVectorFromString;
+using support::ltrim;
+using support::prefixIs;
+using support::rtrim;
+using support::split;
+using support::subst;
+using support::token;
+using support::trim;
+
namespace biblio {
+namespace {
+
+vector<string> const init_possible_cite_commands()
+{
+ char const * const pos[] = {
+ "cite",
+ "citet", "citep", "citealt", "citealp",
+ "citeauthor", "citeyear", "citeyearpar",
+ "citet*", "citep*", "citealt*", "citealp*", "citeauthor*",
+ "Citet", "Citep", "Citealt", "Citealp", "Citeauthor",
+ "Citet*", "Citep*", "Citealt*", "Citealp*", "Citeauthor*",
+ "fullcite",
+ "footcite", "footcitet", "footcitep", "footcitealt",
+ "footcitealp", "footciteauthor", "footciteyear",
+ "footciteyearpar",
+ "citefield",
+ "citetitle",
+ "cite*"
+ };
+ size_t const size_pos = sizeof(pos) / sizeof(pos[0]);
+
+ return vector<string>(pos, pos + size_pos);
+}
+
+
+vector<string> const & possible_cite_commands()
+{
+ static vector<string> const pos = init_possible_cite_commands();
+ return pos;
+}
+
+
+bool is_possible_cite_command(string const & input)
+{
+ vector<string> const & possibles = possible_cite_commands();
+ vector<string>::const_iterator const end = possibles.end();
+ return std::find(possibles.begin(), end, input) != end;
+}
+
+
+string const default_cite_command(CiteEngine engine)
+{
+ string str;
+ switch (engine) {
+ case ENGINE_BASIC:
+ str = "cite";
+ break;
+ case ENGINE_NATBIB_AUTHORYEAR:
+ str = "citet";
+ break;
+ case ENGINE_NATBIB_NUMERICAL:
+ str = "citep";
+ break;
+ case ENGINE_JURABIB:
+ str = "cite";
+ break;
+ }
+ return str;
+}
+
+} // namespace anon
+
+
+string const asValidLatexCommand(string const & input,
+ CiteEngine_enum const & engine)
+{
+ string const default_str = default_cite_command(engine);
+ if (!is_possible_cite_command(input))
+ return default_str;
+
+ string output;
+ switch (engine) {
+ case ENGINE_BASIC:
+ output = default_str;
+ break;
+
+ case ENGINE_NATBIB_AUTHORYEAR:
+ case ENGINE_NATBIB_NUMERICAL:
+ if (input == "cite" || input == "citefield" ||
+ input == "citetitle" || input == "cite*")
+ output = default_str;
+ else if (prefixIs(input, "foot"))
+ output = input.substr(4);
+ else
+ output = input;
+ break;
+
+ case ENGINE_JURABIB: {
+ // Jurabib does not support the 'uppercase' natbib style.
+ if (input[0] == 'C')
+ output = string(1, 'c') + input.substr(1);
+ else
+ output = input;
+
+ // Jurabib does not support the 'full' natbib style.
+ string::size_type const n = output.size() - 1;
+ if (output != "cite*" && output[n] == '*')
+ output = output.substr(0, n);
+
+ break;
+ }
+ }
+
+ return output;
+}
+
+
string const familyName(string const & name)
{
// Very simple parser
// "Surname, F."
// "FirstName Surname"
// "F. Surname"
- string::size_type idx = fname.find(",");
+ string::size_type idx = fname.find(',');
if (idx != string::npos)
return ltrim(fname.substr(0, idx));
- idx = fname.rfind(".");
+ idx = fname.rfind('.');
if (idx != string::npos)
fname = ltrim(fname.substr(idx + 1));
// test if we have a LaTeX Space in front
string const getAbbreviatedAuthor(InfoMap const & map, string const & key)
{
- lyx::Assert(!map.empty());
+ BOOST_ASSERT(!map.empty());
InfoMap::const_iterator it = map.find(key);
if (it == map.end())
}
string author = parseBibTeX(data, "author");
+
if (author.empty())
author = parseBibTeX(data, "editor");
if (authors.empty())
return author;
- author = familyName(authors[0]);
if (authors.size() == 2)
- author += _(" and ") + familyName(authors[1]);
- else if (authors.size() > 2)
- author += _(" et al.");
+ return bformat(_("%1$s and %2$s"),
+ familyName(authors[0]), familyName(authors[1]));
+
+ if (authors.size() > 2)
+ return bformat(_("%1$s et al."), familyName(authors[0]));
- return author;
+ return familyName(authors[0]);
}
string const getYear(InfoMap const & map, string const & key)
{
- lyx::Assert(!map.empty());
+ BOOST_ASSERT(!map.empty());
InfoMap::const_iterator it = map.find(key);
if (it == map.end())
return compare_ascii_no_case(s1, s2) < 0;
}
};
-
+
} // namespace anon
string const getInfo(InfoMap const & map, string const & key)
{
- lyx::Assert(!map.empty());
+ BOOST_ASSERT(!map.empty());
InfoMap::const_iterator it = map.find(key);
if (it == map.end())
if (!year.empty())
result << ", " << year;
- string const result_str = rtrim(STRCONV(result.str()));
+ string const result_str = rtrim(result.str());
if (!result_str.empty())
return result_str;
namespace {
-// The functions doing the dirty work for the search.
-vector<string>::const_iterator
-simpleSearch(InfoMap const & theMap,
- vector<string> const & keys,
- string const & expr,
- vector<string>::const_iterator start,
- Direction dir,
- bool caseSensitive)
+// Escape special chars.
+// All characters are literals except: '.|*?+(){}[]^$\'
+// These characters are literals when preceded by a "\", which is done here
+string const escape_special_chars(string const & expr)
{
- string tmp = expr;
- if (!caseSensitive)
- tmp = lowercase(tmp);
-
- vector<string> searchwords = getVectorFromString(tmp, " ");
-
- // Loop over all keys from start...
- for (vector<string>::const_iterator it = start;
- // End condition is direction-dependent.
- (dir == FORWARD) ? (it<keys.end()) : (it>=keys.begin());
- // increment is direction-dependent.
- (dir == FORWARD) ? (++it) : (--it)) {
-
- string data = (*it);
- InfoMap::const_iterator info = theMap.find(*it);
- if (info != theMap.end())
- data += " " + info->second;
- if (!caseSensitive)
- data = lowercase(data);
-
- bool found = true;
-
- // Loop over all search words...
- for (vector<string>::const_iterator sit = searchwords.begin();
- sit != searchwords.end(); ++sit) {
- if (data.find(*sit) == string::npos) {
- found = false;
- break;
- }
- }
-
- if (found) return it;
- }
-
- return keys.end();
+ // Search for all chars '.|*?+(){}[^$]\'
+ // Note that '[' and '\' must be escaped.
+ // This is a limitation of boost::regex, but all other chars in BREs
+ // are assumed literal.
+ boost::RegEx reg("[].|*?+(){}^$\\[\\\\]");
+
+ // $& is a perl-like expression that expands to all of the current match
+ // The '$' must be prefixed with the escape character '\' for
+ // boost to treat it as a literal.
+ // Thus, to prefix a matched expression with '\', we use:
+ return reg.Merge(expr, "\\\\$&");
}
-vector<string>::const_iterator
-regexSearch(InfoMap const & theMap,
- vector<string> const & keys,
- string const & expr,
- vector<string>::const_iterator start,
- Direction dir)
+// A functor for use with std::find_if, used to ascertain whether a
+// data entry matches the required regex_
+struct RegexMatch : public std::unary_function<string, bool>
{
- boost::regex reg(STRCONV(expr));
-
- for (vector<string>::const_iterator it = start;
- // End condition is direction-dependent.
- (dir == FORWARD) ? (it < keys.end()) : (it >= keys.begin());
- // increment is direction-dependent.
- (dir == FORWARD) ? (++it) : (--it)) {
-
- string data = (*it);
- InfoMap::const_iterator info = theMap.find(*it);
- if (info != theMap.end())
- data += " " + info->second;
-
- if (boost::regex_match(STRCONV(data), reg)) {
- return it;
- }
+ // re and icase are used to construct an instance of boost::RegEx.
+ // if icase is true, then matching is insensitive to case
+ RegexMatch(InfoMap const & m, string const & re, bool icase)
+ : map_(m), regex_(re, icase) {}
+
+ bool operator()(string const & key) const {
+ if (!validRE())
+ return false;
+
+ // the data searched is the key + its associated BibTeX/biblio
+ // fields
+ string data = key;
+ InfoMap::const_iterator info = map_.find(key);
+ if (info != map_.end())
+ data += ' ' + info->second;
+
+ // Attempts to find a match for the current RE
+ // somewhere in data.
+ return regex_.Search(data);
}
- return keys.end();
-}
+ bool validRE() const { return regex_.error_code() == 0; }
+private:
+ InfoMap const map_;
+ mutable boost::RegEx regex_;
+};
} // namespace anon
vector<string>::const_iterator
searchKeys(InfoMap const & theMap,
vector<string> const & keys,
- string const & expr,
+ string const & search_expr,
vector<string>::const_iterator start,
Search type,
Direction dir,
if (start < keys.begin() || start >= keys.end())
return keys.end();
- string search_expr = trim(expr);
- if (search_expr.empty())
+ string expr = trim(search_expr);
+ if (expr.empty())
return keys.end();
if (type == SIMPLE)
- return simpleSearch(theMap, keys, search_expr, start, dir,
- caseSensitive);
+ // We must escape special chars in the search_expr so that
+ // it is treated as a simple string by boost::regex.
+ expr = escape_special_chars(expr);
+
+ // Build the functor that will be passed to find_if.
+ RegexMatch const match(theMap, expr, !caseSensitive);
+ if (!match.validRE())
+ return keys.end();
+
+ // Search the vector of 'keys' from 'start' for one that matches the
+ // predicate 'match'. Searching can be forward or backward from start.
+ if (dir == FORWARD)
+ return std::find_if(start, keys.end(), match);
- return regexSearch(theMap, keys, search_expr, start, dir);
+ vector<string>::const_reverse_iterator rit(start);
+ vector<string>::const_reverse_iterator rend = keys.rend();
+ rit = std::find_if(rit, rend, match);
+
+ if (rit == rend)
+ return keys.end();
+ // This is correct and always safe.
+ // (See Meyer's Effective STL, Item 28.)
+ return (++rit).base();
}
// the \n and in the second we replace it
// with a space
if (!dummy.empty()) {
- if (!contains(dummy, "="))
- data_ += (' ' + dummy);
+ if (!contains(dummy, '='))
+ data_ += ' ' + dummy;
else
data_ += dummy;
}
keyvalue = dummy;
dummy = token(data, ',', Entries++);
while (!contains(dummy, '=') && !dummy.empty()) {
- keyvalue += (',' + dummy);
+ keyvalue += ',' + dummy;
dummy = token(data, ',', Entries++);
}
namespace {
-using namespace biblio;
char const * const citeCommands[] = {
"cite", "citet", "citep", "citealt", "citealp", "citeauthor",
} // namespace anon
-CitationStyle const getCitationStyle(string const & command)
+CitationStyle::CitationStyle(string const & command)
+ : style(CITE), full(false), forceUCase(false)
{
- if (command.empty()) return CitationStyle();
+ if (command.empty())
+ return;
- CitationStyle cs;
string cmd = command;
-
if (cmd[0] == 'C') {
- cs.forceUCase = true;
+ forceUCase = true;
cmd[0] = 'c';
}
- size_t n = cmd.size() - 1;
- if (cmd[n] == '*') {
- cs.full = true;
+ string::size_type const n = cmd.size() - 1;
+ if (cmd != "cite" && cmd[n] == '*') {
+ full = true;
cmd = cmd.substr(0,n);
}
if (ptr != last) {
size_t idx = ptr - citeCommands;
- cs.style = citeStyles[idx];
+ style = citeStyles[idx];
}
-
- return cs;
}
-string const getCiteCommand(CiteStyle command, bool full, bool forceUCase)
+string const CitationStyle::asLatexStr() const
{
- string cite = citeCommands[command];
+ string cite = citeCommands[style];
if (full) {
CiteStyle const * last = citeStylesFull + nCiteStylesFull;
- if (std::find(citeStylesFull, last, command) != last)
- cite += "*";
+ if (std::find(citeStylesFull, last, style) != last)
+ cite += '*';
}
if (forceUCase) {
CiteStyle const * last = citeStylesUCase + nCiteStylesUCase;
- if (std::find(citeStylesUCase, last, command) != last)
+ if (std::find(citeStylesUCase, last, style) != last)
cite[0] = 'C';
}
}
-vector<CiteStyle> const getCiteStyles(bool usingNatbib)
+CiteEngine_enum getEngine(Buffer const & buffer)
{
- unsigned int nStyles = 1;
+ return buffer.params().cite_engine;
+}
+
+
+vector<CiteStyle> const getCiteStyles(CiteEngine_enum const & engine)
+{
+ unsigned int nStyles = 0;
unsigned int start = 0;
- if (usingNatbib) {
+
+ switch (engine) {
+ case ENGINE_BASIC:
+ nStyles = 1;
+ 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<CiteStyle> styles(nStyles);
+ typedef vector<CiteStyle> cite_vec;
- vector<CiteStyle>::size_type i = 0;
+ cite_vec styles(nStyles);
+ cite_vec::size_type i = 0;
int j = start;
- for (; i != styles.size(); ++i, ++j) {
+ for (; i != styles.size(); ++i, ++j)
styles[i] = citeStyles[j];
- }
return styles;
}
break;
case CITEYEARPAR:
- str = "(" + year + ")";
+ str = '(' + year + ')';
break;
}
switch (styles[i]) {
case CITE:
+ // jurabib only: Author/Annotator
+ // (i.e. the "before" field, 2nd opt arg)
+ str = author + "/<" + _("before") + '>';
+ break;
+
case CITET:
- str = author + " (" + year + ")";
+ str = author + " (" + year + ')';
break;
case CITEP:
- str = "(" + author + ", " + year + ")";
+ str = '(' + author + ", " + year + ')';
break;
case CITEALT:
- str = author + " " + year ;
+ str = author + ' ' + year ;
break;
case CITEALP:
break;
case CITEYEARPAR:
- str = "(" + year + ")";
+ str = '(' + year + ')';
break;
}
}
} // namespace biblio
+} // namespace lyx
projects / features.git / blobdiff