X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCounters.cpp;h=114b18020b3d0b34690318f5046391f7e09314f3;hb=cfcc57bd895fc3c74dd47b8cb40fd40c0c57dbcb;hp=39e177b1f6b42b2a921599e88a14432ced912150;hpb=52ccb98354af7f1bd10b171c920d203878b355fd;p=lyx.git diff --git a/src/Counters.cpp b/src/Counters.cpp index 39e177b1f6..114b18020b 100644 --- a/src/Counters.cpp +++ b/src/Counters.cpp @@ -3,10 +3,10 @@ * This file is part of LyX, the document processor. * Licence details can be found in the file COPYING. * - * \author Lars Gullik Bjønnes + * \author Lars Gullik Bjønnes * \author Martin Vermeer - * \author André Pönitz - * \author Richard Heck (roman numerals) + * \author André Pönitz + * \author Richard Kimberly Heck (roman numerals) * * Full author contact details are available in file CREDITS. */ @@ -14,13 +14,18 @@ #include #include "Counters.h" +#include "Layout.h" +#include "Lexer.h" #include "support/convert.h" +#include "support/counter_reps.h" #include "support/debug.h" +#include "support/docstring.h" +#include "support/gettext.h" +#include "support/lassert.h" #include "support/lstrings.h" -#include - +#include #include using namespace std; @@ -30,19 +35,130 @@ namespace lyx { Counter::Counter() + : initial_value_(0), saved_value_(0) { reset(); } -Counter::Counter(docstring const & mc, docstring const & ls, - docstring const & lsa) - : master_(mc), labelstring_(ls), labelstringappendix_(lsa) +Counter::Counter(docstring const & mc, docstring const & ls, + docstring const & lsa, docstring const & prettyformat, + docstring const & guiname) + : initial_value_(0), saved_value_(0), parent_(mc), labelstring_(ls), + labelstringappendix_(lsa), prettyformat_(prettyformat), guiname_(guiname) { reset(); } +bool Counter::read(Lexer & lex) +{ + enum { + CT_WITHIN = 1, + CT_LABELSTRING, + CT_LABELSTRING_APPENDIX, + CT_PRETTYFORMAT, + CT_INITIALVALUE, + CT_GUINAME, + CT_LATEXNAME, + CT_REFFORMAT, + CT_END + }; + + LexerKeyword counterTags[] = { + { "end", CT_END }, + { "guiname", CT_GUINAME }, + { "initialvalue", CT_INITIALVALUE}, + { "labelstring", CT_LABELSTRING }, + { "labelstringappendix", CT_LABELSTRING_APPENDIX }, + { "latexname", CT_LATEXNAME }, + { "prettyformat", CT_PRETTYFORMAT }, + { "refformat", CT_REFFORMAT }, + { "within", CT_WITHIN } + }; + + lex.pushTable(counterTags); + + bool getout = false; + while (!getout && lex.isOK()) { + int le = lex.lex(); + switch (le) { + case Lexer::LEX_UNDEF: + lex.printError("Unknown counter tag `$$Token'"); + continue; + default: + break; + } + switch (le) { + case CT_WITHIN: + lex.next(); + parent_ = lex.getDocString(); + if (parent_ == "none") + parent_.erase(); + break; + case CT_INITIALVALUE: + lex.next(); + initial_value_ = lex.getInteger(); + // getInteger() returns -1 on error, and larger + // negative values do not make much sense. + // In the other case, we subtract one, since the + // counter will be incremented before its first use. + if (initial_value_ <= -1) + initial_value_ = 0; + else + initial_value_ -= 1; + break; + case CT_PRETTYFORMAT: + lex.next(); + prettyformat_ = lex.getDocString(); + break; + case CT_REFFORMAT: { + lex.next(); + docstring const key = lex.getDocString(); + lex.next(); + docstring const value = lex.getDocString(); + ref_formats_[key] = value; + // LYXERR0("refformat: " << key << " => " << value); + break; + } + case CT_LABELSTRING: + lex.next(); + labelstring_ = lex.getDocString(); + labelstringappendix_ = labelstring_; + break; + case CT_LABELSTRING_APPENDIX: + lex.next(); + labelstringappendix_ = lex.getDocString(); + break; + case CT_GUINAME: + lex.next(); + guiname_ = lex.getDocString(); + break; + case CT_LATEXNAME: + lex.next(); + latexname_ = lex.getDocString(); + break; + case CT_END: + getout = true; + break; + } + // fall back on GuiName if PrettyFormat is empty + if (prettyformat_.empty()) { + if (guiname_.empty()) + prettyformat_ = from_ascii("##"); + else + prettyformat_ = "## (" + guiname_ + ")"; + } + } + + // Here if have a full counter if getout == true + if (!getout) + LYXERR0("No End tag found for counter!"); + lex.popTable(); + return getout; +} + + void Counter::set(int v) { value_ = v; @@ -61,6 +177,18 @@ int Counter::value() const } +void Counter::saveValue() +{ + saved_value_ = value_; +} + + +void Counter::restoreValue() +{ + value_ = saved_value_; +} + + void Counter::step() { ++value_; @@ -69,53 +197,99 @@ void Counter::step() void Counter::reset() { - value_ = 0; + value_ = initial_value_; +} + + +docstring const & Counter::refFormat(docstring const & prefix) const +{ + map::const_iterator it = ref_formats_.find(prefix); + if (it == ref_formats_.end()) + return prettyformat_; + return it->second; } -docstring const & Counter::master() const +docstring const & Counter::parent() const { - return master_; + return parent_; } -docstring const & Counter::labelString() const +bool Counter::checkAndRemoveParent(docstring const & cnt) { - return labelstring_; + if (parent_ != cnt) + return false; + parent_ = docstring(); + return true; } -docstring const & Counter::labelStringAppendix() const +docstring const & Counter::labelString(bool in_appendix) const { - return labelstringappendix_; + return in_appendix ? labelstringappendix_ : labelstring_; +} + + +Counter::StringMap & Counter::flatLabelStrings(bool in_appendix) const +{ + return in_appendix ? flatlabelstringappendix_ : flatlabelstring_; +} + + +Counters::Counters() : appendix_(false), subfloat_(false), longtable_(false) +{ + layout_stack_.push_back(nullptr); + counter_stack_.push_back(from_ascii("")); } void Counters::newCounter(docstring const & newc, - docstring const & masterc, + docstring const & parentc, docstring const & ls, - docstring const & lsa) + docstring const & lsa, + docstring const & prettyformat, + docstring const & guiname) { - if (!masterc.empty() && !hasCounter(masterc)) { - lyxerr << "Master counter does not exist: " - << to_utf8(masterc) + if (!parentc.empty() && !hasCounter(parentc)) { + lyxerr << "Parent counter does not exist: " + << to_utf8(parentc) << endl; return; } - counterList[newc] = Counter(masterc, ls, lsa); + counterList_[newc] = Counter(parentc, ls, lsa, prettyformat, guiname); } bool Counters::hasCounter(docstring const & c) const { - return counterList.find(c) != counterList.end(); + return counterList_.find(c) != counterList_.end(); +} + + +bool Counters::read(Lexer & lex, docstring const & name, bool makenew) +{ + if (hasCounter(name)) { + LYXERR(Debug::TCLASS, "Reading existing counter " << to_utf8(name)); + return counterList_[name].read(lex); + } + + LYXERR(Debug::TCLASS, "Reading new counter " << to_utf8(name)); + Counter cnt; + bool success = cnt.read(lex); + // if makenew is false, we will just discard what we read + if (success && makenew) + counterList_[name] = cnt; + else if (!success) + LYXERR0("Error reading counter `" << name << "'!"); + return success; } void Counters::set(docstring const & ctr, int const val) { - CounterList::iterator const it = counterList.find(ctr); - if (it == counterList.end()) { + CounterList::iterator const it = counterList_.find(ctr); + if (it == counterList_.end()) { lyxerr << "set: Counter does not exist: " << to_utf8(ctr) << endl; return; @@ -126,8 +300,8 @@ void Counters::set(docstring const & ctr, int const val) void Counters::addto(docstring const & ctr, int const val) { - CounterList::iterator const it = counterList.find(ctr); - if (it == counterList.end()) { + CounterList::iterator const it = counterList_.find(ctr); + if (it == counterList_.end()) { lyxerr << "addto: Counter does not exist: " << to_utf8(ctr) << endl; return; @@ -138,8 +312,8 @@ void Counters::addto(docstring const & ctr, int const val) int Counters::value(docstring const & ctr) const { - CounterList::const_iterator const cit = counterList.find(ctr); - if (cit == counterList.end()) { + CounterList::const_iterator const cit = counterList_.find(ctr); + if (cit == counterList_.end()) { lyxerr << "value: Counter does not exist: " << to_utf8(ctr) << endl; return 0; @@ -148,169 +322,161 @@ int Counters::value(docstring const & ctr) const } -void Counters::step(docstring const & ctr) +void Counters::saveValue(docstring const & ctr) const { - CounterList::iterator it = counterList.find(ctr); - if (it == counterList.end()) { - lyxerr << "step: Counter does not exist: " + CounterList::const_iterator const cit = counterList_.find(ctr); + if (cit == counterList_.end()) { + lyxerr << "value: Counter does not exist: " << to_utf8(ctr) << endl; return; } - - it->second.step(); - it = counterList.begin(); - CounterList::iterator const end = counterList.end(); - for (; it != end; ++it) { - if (it->second.master() == ctr) { - it->second.reset(); - } - } + Counter const & cnt = cit->second; + Counter & ccnt = const_cast(cnt); + ccnt.saveValue(); } -void Counters::reset() +void Counters::restoreValue(docstring const & ctr) const { - appendix_ = false; - current_float_.erase(); - CounterList::iterator it = counterList.begin(); - CounterList::iterator const end = counterList.end(); - for (; it != end; ++it) { - it->second.reset(); + CounterList::const_iterator const cit = counterList_.find(ctr); + if (cit == counterList_.end()) { + lyxerr << "value: Counter does not exist: " + << to_utf8(ctr) << endl; + return; } + Counter const & cnt = cit->second; + Counter & ccnt = const_cast(cnt); + ccnt.restoreValue(); } -void Counters::reset(docstring const & match) +void Counters::resetChildren(docstring const & count) { - BOOST_ASSERT(!match.empty()); - - CounterList::iterator it = counterList.begin(); - CounterList::iterator end = counterList.end(); - for (; it != end; ++it) { - if (it->first.find(match) != string::npos) - it->second.reset(); + for (auto & ctr : counterList_) { + if (ctr.second.parent() == count) { + ctr.second.reset(); + resetChildren(ctr.first); + } } } -void Counters::copy(Counters & from, Counters & to, docstring const & match) +void Counters::stepParent(docstring const & ctr, UpdateType utype) { - CounterList::iterator it = counterList.begin(); - CounterList::iterator end = counterList.end(); - for (; it != end; ++it) { - if (it->first.find(match) != string::npos || match == "") { - to.set(it->first, from.value(it->first)); - } + CounterList::iterator it = counterList_.find(ctr); + if (it == counterList_.end()) { + lyxerr << "step: Counter does not exist: " + << to_utf8(ctr) << endl; + return; } + step(it->second.parent(), utype); } -namespace { - -char loweralphaCounter(int const n) +void Counters::step(docstring const & ctr, UpdateType /* deleted */) { - if (n < 1 || n > 26) - return '?'; - return 'a' + n - 1; + CounterList::iterator it = counterList_.find(ctr); + if (it == counterList_.end()) { + lyxerr << "step: Counter does not exist: " + << to_utf8(ctr) << endl; + return; + } + + it->second.step(); + LBUFERR(!counter_stack_.empty()); + counter_stack_.pop_back(); + counter_stack_.push_back(ctr); + + resetChildren(ctr); } -char alphaCounter(int const n) +docstring const & Counters::guiName(docstring const & cntr) const { - if (n < 1 || n > 26) - return '?'; - return 'A' + n - 1; + CounterList::const_iterator it = counterList_.find(cntr); + if (it == counterList_.end()) { + lyxerr << "step: Counter does not exist: " + << to_utf8(cntr) << endl; + return empty_docstring(); + } + + docstring const & guiname = it->second.guiName(); + if (guiname.empty()) + return cntr; + return guiname; } -char hebrewCounter(int const n) +docstring const & Counters::latexName(docstring const & cntr) const { - static const char hebrew[22] = { - '\xe0', '\xe1', '\xe2', '\xe3', '\xe4', '\xe5', '\xe6', '\xe7', '\xe8', - '\xe9', '\xeb', '\xec', '\xee', '\xf0', '\xf1', '\xf2', '\xf4', '\xf6', - '\xf7', '\xf8', '\xf9', '\xfa' - }; + CounterList::const_iterator it = counterList_.find(cntr); + if (it == counterList_.end()) { + lyxerr << "step: Counter does not exist: " + << to_utf8(cntr) << endl; + return empty_docstring(); + } - if (n < 1 || n > 22) - return '?'; - return hebrew[n - 1]; + docstring const & latexname = it->second.latexName(); + if (latexname.empty()) + return cntr; + return latexname; } +void Counters::reset() +{ + appendix_ = false; + subfloat_ = false; + current_float_.erase(); + for (auto & ctr : counterList_) + ctr.second.reset(); + counter_stack_.clear(); + counter_stack_.push_back(from_ascii("")); + layout_stack_.clear(); + layout_stack_.push_back(nullptr); +} + -//On the special cases, see http://mathworld.wolfram.com/RomanNumerals.html -//and for a list of roman numerals up to and including 3999, see -//http://www.research.att.com/~njas/sequences/a006968.txt. (Thanks to Joost -//for this info.) -docstring const romanCounter(int const n) +void Counters::reset(docstring const & match) { - static char const * const ones[9] = { - "I", "II", "III", "IV", "V", - "VI", "VII", "VIII", "IX" - }; - - static char const * const tens[9] = { - "X", "XX", "XXX", "XL", "L", - "LX", "LXX", "LXXX", "XC" - }; - - static char const * const hunds[9] = { - "C", "CC", "CCC", "CD", "D", - "DC", "DCC", "DCCC", "CM" - }; - - if (n > 1000 || n < 1) - return from_ascii("??"); - - int val = n; - string roman; - switch (n) { - //special cases - case 900: - roman = "CM"; - break; - case 400: - roman = "CD"; - break; - default: - if (val >= 100) { - int hundreds = val / 100; - roman = hunds[hundreds - 1]; - val = val % 100; - } - if (val >= 10) { - switch (val) { - //special case - case 90: - roman = roman + "XC"; - val = 0; //skip next - break; - default: - int tensnum = val / 10; - roman = roman + tens[tensnum - 1]; - val = val % 10; - } // end switch - } // end tens - if (val > 0) - roman = roman + ones[val -1]; + LASSERT(!match.empty(), return); + + for (auto & ctr : counterList_) { + if (ctr.first.find(match) != string::npos) + ctr.second.reset(); } - return from_ascii(roman); } -docstring const lowerromanCounter(int const n) +bool Counters::copy(docstring const & cnt, docstring const & newcnt) { - return lowercase(romanCounter(n)); + auto const it = counterList_.find(cnt); + if (it == counterList_.end()) + return false; + counterList_[newcnt] = it->second; + return true; } -} // namespace anon + +bool Counters::remove(docstring const & cnt) +{ + bool retval = counterList_.erase(cnt); + if (!retval) + return false; + for (auto & ctr : counterList_) { + if (ctr.second.checkAndRemoveParent(cnt)) + LYXERR(Debug::TCLASS, "Removed parent counter `" + + to_utf8(cnt) + "' from counter: " + to_utf8(ctr.first)); + } + return retval; +} docstring Counters::labelItem(docstring const & ctr, - docstring const & numbertype) + docstring const & numbertype) const { - CounterList::const_iterator const cit = counterList.find(ctr); - if (cit == counterList.end()) { + CounterList::const_iterator const cit = counterList_.find(ctr); + if (cit == counterList_.end()) { lyxerr << "Counter " << to_utf8(ctr) << " does not exist." << endl; @@ -334,77 +500,109 @@ docstring Counters::labelItem(docstring const & ctr, if (numbertype == "Roman") return romanCounter(val); + if (numbertype == "fnsymbol") + return fnsymbolCounter(val); + + if (numbertype == "superarabic") + return superarabicCounter(val); + return convert(val); } -docstring Counters::theCounter(docstring const & counter) +docstring Counters::theCounter(docstring const & counter, + string const & lang) const { - std::set callers; - return theCounter(counter, callers); + CounterList::const_iterator it = counterList_.find(counter); + if (it == counterList_.end()) + return from_ascii("#"); + Counter const & ctr = it->second; + Counter::StringMap & sm = ctr.flatLabelStrings(appendix()); + Counter::StringMap::iterator smit = sm.find(lang); + if (smit != sm.end()) + return counterLabel(smit->second, lang); + + vector callers; + docstring const & fls = flattenLabelString(counter, appendix(), + lang, callers); + sm[lang] = fls; + return counterLabel(fls, lang); } -docstring Counters::theCounter(docstring const & counter, - std::set & callers) + +docstring Counters::flattenLabelString(docstring const & counter, + bool in_appendix, + string const & lang, + vector & callers) const { - if (!hasCounter(counter)) + if (find(callers.begin(), callers.end(), counter) != callers.end()) { + // recursion detected + lyxerr << "Warning: Recursion in label for counter `" + << counter << "' detected" + << endl; return from_ascii("??"); + } - docstring label; - - if (callers.find(counter) == callers.end()) { - - pair::iterator, bool> result = callers.insert(counter); - - Counter const & c = counterList[counter]; - docstring ls = appendix() ? c.labelStringAppendix() : c.labelString(); + CounterList::const_iterator it = counterList_.find(counter); + if (it == counterList_.end()) + return from_ascii("#"); + Counter const & c = it->second; - if (ls.empty()) { - if (!c.master().empty()) - ls = from_ascii("\\the") + c.master() + from_ascii("."); - ls += from_ascii("\\arabic{") + counter + "}"; - } + docstring ls = translateIfPossible(c.labelString(in_appendix), lang); - label = counterLabel(ls, &callers); + callers.push_back(counter); + if (ls.empty()) { + if (!c.parent().empty()) + ls = flattenLabelString(c.parent(), in_appendix, lang, callers) + + from_ascii("."); + callers.pop_back(); + return ls + from_ascii("\\arabic{") + counter + "}"; + } - callers.erase(result.first); - } else { - // recursion detected - lyxerr << "Warning: Recursion in label for counter `" - << counter << "' detected" - << endl; + while (true) { + //lyxerr << "ls=" << to_utf8(ls) << endl; + size_t const i = ls.find(from_ascii("\\the"), 0); + if (i == docstring::npos) + break; + size_t const j = i + 4; + size_t k = j; + while (k < ls.size() && lowercase(ls[k]) >= 'a' + && lowercase(ls[k]) <= 'z') + ++k; + docstring const newc = ls.substr(j, k - j); + docstring const repl = flattenLabelString(newc, in_appendix, + lang, callers); + ls.replace(i, k - j + 4, repl); } + callers.pop_back(); - return label; + return ls; } docstring Counters::counterLabel(docstring const & format, - std::set * callers) + string const & lang) const { docstring label = format; // FIXME: Using regexps would be better, but we compile boost without // wide regexps currently. - + docstring const the = from_ascii("\\the"); while (true) { - //lyxerr << "label=" << to_utf8(label) << endl; - size_t const i = label.find(from_ascii("\\the"), 0); + //lyxerr << "label=" << label << endl; + size_t const i = label.find(the, 0); if (i == docstring::npos) break; - size_t j = i + 4; + size_t const j = i + 4; size_t k = j; - while (k < label.size() && lowercase(label[k]) >= 'a' + while (k < label.size() && lowercase(label[k]) >= 'a' && lowercase(label[k]) <= 'z') ++k; - docstring counter = label.substr(j, k - j); - docstring repl = callers? theCounter(counter, *callers): - theCounter(counter); - label.replace(i, k - j + 4, repl); + docstring const newc(label, j, k - j); + label.replace(i, k - i, theCounter(newc, lang)); } - while (true) { - //lyxerr << "label=" << to_utf8(label) << endl; + //lyxerr << "label=" << label << endl; size_t const i = label.find('\\', 0); if (i == docstring::npos) @@ -417,13 +615,101 @@ docstring Counters::counterLabel(docstring const & format, break; docstring const numbertype(label, i + 1, j - i - 1); docstring const counter(label, j + 1, k - j - 1); - docstring const rep = labelItem(counter, numbertype); - label = docstring(label, 0, i) + rep - + docstring(label, k + 1, docstring::npos); + label.replace(i, k + 1 - i, labelItem(counter, numbertype)); } - //lyxerr << "DONE! label=" << to_utf8(label) << endl; + //lyxerr << "DONE! label=" << label << endl; return label; } +docstring Counters::formattedCounter(docstring const & name, + docstring const & prex, string const & lang) const +{ + CounterList::const_iterator it = counterList_.find(name); + if (it == counterList_.end()) + return from_ascii("#"); + Counter const & ctr = it->second; + + docstring const value = theCounter(name, lang); + docstring const format = + translateIfPossible(counterLabel(ctr.refFormat(prex), lang), lang); + if (format.empty()) + return value; + return subst(format, from_ascii("##"), value); +} + + +docstring Counters::prettyCounter(docstring const & name, + string const & lang) const +{ + CounterList::const_iterator it = counterList_.find(name); + if (it == counterList_.end()) + return from_ascii("#"); + Counter const & ctr = it->second; + + docstring const value = theCounter(name, lang); + docstring const & format = + translateIfPossible(counterLabel(ctr.prettyFormat(), lang), lang); + if (format.empty()) + return value; + return subst(format, from_ascii("##"), value); +} + + +docstring Counters::currentCounter() const +{ + LBUFERR(!counter_stack_.empty()); + return counter_stack_.back(); +} + + +void Counters::setActiveLayout(Layout const & lay) +{ + LASSERT(!layout_stack_.empty(), return); + Layout const * const lastlay = layout_stack_.back(); + // we want to check whether the layout has changed and, if so, + // whether we are coming out of or going into an environment. + if (!lastlay) { + layout_stack_.pop_back(); + layout_stack_.push_back(&lay); + if (lay.isEnvironment()) + beginEnvironment(); + } else if (lastlay->name() != lay.name()) { + layout_stack_.pop_back(); + layout_stack_.push_back(&lay); + if (lastlay->isEnvironment()) { + // we are coming out of an environment + // LYXERR0("Out: " << lastlay->name()); + endEnvironment(); + } + if (lay.isEnvironment()) { + // we are going into a new environment + // LYXERR0("In: " << lay.name()); + beginEnvironment(); + } + } +} + + +void Counters::beginEnvironment() +{ + counter_stack_.push_back(counter_stack_.back()); +} + + +void Counters::endEnvironment() +{ + LASSERT(!counter_stack_.empty(), return); + counter_stack_.pop_back(); +} + + +vector Counters::listOfCounters() const { + vector ret; + for(auto const & k : counterList_) + ret.emplace_back(k.first); + return ret; +} + + } // namespace lyx