X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMacroTable.cpp;h=d23855c511f5bd3fadd26661f81fc2d0b97a9abf;hb=02e82157ec583c3900e359de86be79fac6512387;hp=17e177b4228beff368d249b43bb17959d4ce662f;hpb=f7b1c86393d890d5d473279d88e26bb78f8c1275;p=lyx.git diff --git a/src/mathed/MacroTable.cpp b/src/mathed/MacroTable.cpp index 17e177b422..d23855c511 100644 --- a/src/mathed/MacroTable.cpp +++ b/src/mathed/MacroTable.cpp @@ -3,59 +3,81 @@ * This file is part of LyX, the document processor. * Licence details can be found in the file COPYING. * - * \author André Pönitz + * \author André Pönitz * * Full author contact details are available in file CREDITS. */ #include +#include "InsetMathSqrt.h" #include "MacroTable.h" #include "MathMacroTemplate.h" #include "MathMacroArgument.h" +#include "MathParser.h" +#include "MathStream.h" #include "MathSupport.h" -#include "InsetMathSqrt.h" +#include "InsetMathNest.h" -#include "debug.h" +#include "Buffer.h" #include "DocIterator.h" +#include "InsetList.h" +#include "Text.h" -#include +#include "support/debug.h" +#include "support/gettext.h" +#include "support/lassert.h" #include +using namespace std; namespace lyx { -using std::endl; -using std::istringstream; -using std::map; -using std::pair; -using std::string; -using std::vector; -using std::size_t; +///////////////////////////////////////////////////////////////////// +// +// MacroData +// +///////////////////////////////////////////////////////////////////// -MacroData::MacroData() - : numargs_(0), lockCount_(0) +MacroData::MacroData(Buffer * buf) + : buffer_(buf), queried_(true), numargs_(0), sym_(0), optionals_(0), + lockCount_(0), redefinition_(false), type_(MacroTypeNewcommand) {} -MacroData::MacroData(docstring const & def, int numargs, docstring const & disp, string const & requires) - : def_(def), numargs_(numargs), disp_(disp), requires_(requires), lockCount_(0) -{} +MacroData::MacroData(Buffer * buf, DocIterator const & pos) + : buffer_(buf), pos_(pos), queried_(false), numargs_(0), sym_(0), + optionals_(0), lockCount_(0), redefinition_(false), + type_(MacroTypeNewcommand) +{ +} -void MacroData::expand(vector const & args, MathData & to) const +MacroData::MacroData(Buffer * buf, MathMacroTemplate const & macro) + : buffer_(buf), queried_(false), numargs_(0), sym_(0), optionals_(0), + lockCount_(0), redefinition_(false), type_(MacroTypeNewcommand) { - InsetMathSqrt inset; // Hack. Any inset with a cell would do. - // FIXME UNICODE - asArray(disp_.empty() ? def_ : disp_, inset.cell(0)); + queryData(macro); +} + + +bool MacroData::expand(vector const & args, MathData & to) const +{ + updateData(); + + // Hack. Any inset with a cell would do. + InsetMathSqrt inset(const_cast(buffer_)); + + docstring const & definition(display_.empty() ? definition_ : display_); + asArray(definition, inset.cell(0), Parse::QUIET); //lyxerr << "MathData::expand: args: " << args << endl; - //lyxerr << "MathData::expand: ar: " << inset.cell(0) << endl; - for (DocIterator it = doc_iterator_begin(inset); it; it.forwardChar()) { + //LYXERR0("MathData::expand: ar: " << inset.cell(0)); + for (DocIterator it = doc_iterator_begin(buffer_, &inset); it; it.forwardChar()) { if (!it.nextInset()) continue; - if (it.nextInset()->lyxCode() != MATHMACROARG_CODE) + if (it.nextInset()->lyxCode() != MATH_MACROARG_CODE) continue; //it.cell().erase(it.pos()); //it.cell().insert(it.pos(), it.nextInset()->asInsetMath() @@ -65,47 +87,175 @@ void MacroData::expand(vector const & args, MathData & to) const it.cell().insert(it.pos(), args[n - 1]); } } - //lyxerr << "MathData::expand: res: " << inset.cell(0) << endl; + //LYXERR0("MathData::expand: res: " << inset.cell(0)); to = inset.cell(0); + // If the result is equal to the definition then we either have a + // recursive loop, or the definition did not contain any macro in the + // first place. + return asString(to) != definition; } -// The global table. -MacroTable & MacroTable::globalMacros() +size_t MacroData::optionals() const { - static MacroTable theGlobalMacros; - return theGlobalMacros; + updateData(); + return optionals_; +} + + +vector const & MacroData::defaults() const +{ + updateData(); + return defaults_; } -bool MacroTable::has(docstring const & name) const +string const MacroData::requires() const { - return find(name) != end(); + if (sym_) + return sym_->requires; + return string(); } -MacroData const & MacroTable::get(docstring const & name) const +bool MacroData::hidden() const +{ + if (sym_) + return sym_->hidden; + return false; +} + + +docstring const MacroData::xmlname() const +{ + if (sym_) + return sym_->xmlname; + return docstring(); +} + + +char const * MacroData::MathMLtype() const +{ + return sym_ ? sym_->MathMLtype() : 0; +} + + +void MacroData::unlock() const +{ + --lockCount_; + LASSERT(lockCount_ >= 0, lockCount_ = 0); +} + + +void MacroData::queryData(MathMacroTemplate const & macro) const +{ + if (queried_) + return; + + queried_ = true; + definition_ = macro.definition(); + numargs_ = macro.numArgs(); + display_ = macro.displayDefinition(); + redefinition_ = macro.redefinition(); + type_ = macro.type(); + optionals_ = macro.numOptionals(); + + macro.getDefaults(defaults_); +} + + +void MacroData::updateData() const +{ + if (queried_) + return; + + LBUFERR(buffer_); + + // Try to fix position DocIterator. Should not do anything in theory. + pos_.fixIfBroken(); + + // find macro template + Inset * inset = pos_.nextInset(); + if (inset == 0 || inset->lyxCode() != MATHMACRO_CODE) { + lyxerr << "BUG: No macro template found by MacroData" << endl; + return; + } + + // query the data from the macro template + queryData(static_cast(*inset)); +} + + +int MacroData::write(odocstream & os, bool overwriteRedefinition) const +{ + updateData(); + + // find macro template + Inset * inset = pos_.nextInset(); + if (inset == 0 || inset->lyxCode() != MATHMACRO_CODE) { + lyxerr << "BUG: No macro template found by MacroData" << endl; + return 0; + } + + // output template + MathMacroTemplate const & tmpl = + static_cast(*inset); + otexrowstream ots(os); + WriteStream wi(ots, false, true, WriteStream::wsDefault); + return tmpl.write(wi, overwriteRedefinition); +} + + +///////////////////////////////////////////////////////////////////// +// +// The global table of macros +// +///////////////////////////////////////////////////////////////////// + +MacroTable & MacroTable::globalMacros() +{ + static MacroTable theGlobalMacros; + return theGlobalMacros; +} + + +MacroData const * MacroTable::get(docstring const & name) const { const_iterator it = find(name); - BOOST_ASSERT(it != end()); - return it->second; + return it == end() ? 0 : &it->second; } -void MacroTable::insert(docstring const & name, MacroData const & data) +MacroTable::iterator +MacroTable::insert(docstring const & name, MacroData const & data) { //lyxerr << "MacroTable::insert: " << to_utf8(name) << endl; - operator[](name) = data; + iterator it = find(name); + if (it == end()) + it = map::insert( + make_pair(name, data)).first; + else + it->second = data; + return it; } -void MacroTable::insert(docstring const & def, string const & requires) +MacroTable::iterator +MacroTable::insert(Buffer * buf, docstring const & def) { //lyxerr << "MacroTable::insert, def: " << to_utf8(def) << endl; - MathMacroTemplate mac(def); - MacroData data = mac.asMacroData(); - data.requires() = requires; - insert(mac.name(), data); + MathMacroTemplate mac(buf); + mac.fromString(def); + MacroData data(buf, mac); + return insert(mac.name(), data); +} + + +void MacroTable::getMacroNames(std::set & names, bool gethidden) const +{ + for (const_iterator it = begin(); it != end(); ++it) + if (gethidden || !it->second.hidden()) + names.insert(it->first); } @@ -114,11 +264,28 @@ void MacroTable::dump() lyxerr << "\n------------------------------------------" << endl; for (const_iterator it = begin(); it != end(); ++it) lyxerr << to_utf8(it->first) - << " [" << to_utf8(it->second.def()) << "] : " - << " [" << to_utf8(it->second.disp()) << "] : " + << " [" << to_utf8(it->second.definition()) << "] : " + << " [" << to_utf8(it->second.display()) << "] : " << endl; lyxerr << "------------------------------------------" << endl; } +///////////////////////////////////////////////////////////////////// +// +// MacroContext +// +///////////////////////////////////////////////////////////////////// + +MacroContext::MacroContext(Buffer const * buf, DocIterator const & pos) + : buf_(buf), pos_(pos) +{ +} + + +MacroData const * MacroContext::get(docstring const & name) const +{ + return buf_->getMacro(name, pos_); +} + } // namespace lyx