X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMacroTable.h;h=3a1fed4fa682bb89d833f54d4d4dc1cb6b51e215;hb=30d3fcd640c180407a8a1db7679cca42eaa9e0c1;hp=082cf675d63f0d1547bfcfec70d17e016e239368;hpb=565475a43917af9c52a3d9d8272e020160d0b971;p=lyx.git diff --git a/src/mathed/MacroTable.h b/src/mathed/MacroTable.h index 082cf675d6..3a1fed4fa6 100644 --- a/src/mathed/MacroTable.h +++ b/src/mathed/MacroTable.h @@ -13,59 +13,79 @@ #ifndef MATH_MACROTABLE_H #define MATH_MACROTABLE_H -#include "support/docstring.h" +#include "DocIterator.h" -#include +#include "support/docstring.h" #include +#include #include namespace lyx { class Buffer; class MathData; +class MathMacroTemplate; class Paragraph; +enum MacroType { + MacroTypeNewcommand, + MacroTypeNewcommandx, + MacroTypeDef +}; + /// class MacroData { public: + /// Constructor to make STL containers happy + MacroData(Buffer * buf = 0); + /// Create lazy MacroData which only queries the macro template when needed + MacroData(Buffer * buf, DocIterator const & pos); + /// Create non-lazy MacroData which directly queries the macro template + MacroData(Buffer * buf, MathMacroTemplate const & macro); + /// - MacroData(); - /// - MacroData(docstring const & definition, std::vector const & defaults, - int nargs, int optionals, - docstring const & display, std::string const & requires); - /// - docstring const & definition() const { return definition_; } + docstring const & definition() const { updateData(); return definition_; } /// - docstring const & display() const { return display_; } + docstring const & display() const { updateData(); return display_; } /// arity including optional arguments (if there is any) - size_t numargs() const { return numargs_; } - /// replace #1,#2,... by given MathAtom 0,1,.., _including_ the possible optional argument + size_t numargs() const { updateData(); return numargs_; } + /// replace #1,#2,... by given MathAtom 0,1,.., _including_ the possible + /// optional argument void expand(std::vector const & from, MathData & to) const; /// number of optional arguments size_t optionals() const; /// std::vector const & defaults() const; /// - std::string requires() const { return requires_; } + std::string const & requires() const { updateData(); return requires_; } /// - std::string & requires() { return requires_; } + std::string & requires() { updateData(); return requires_; } /// lock while being drawn to avoid recursions int lock() const { return ++lockCount_; } /// is it being drawn? bool locked() const { return lockCount_ != 0; } /// - void unlock() const { --lockCount_; BOOST_ASSERT(lockCount_ >= 0); } + void unlock() const; /// bool redefinition() const { return redefinition_; } /// void setRedefinition(bool redefined) { redefinition_ = redefined; } + + /// + MacroType type() const { return type_; } + /// + MacroType & type() { return type_; } + /// output as TeX macro, only works for lazy MacroData!!! + int write(odocstream & os, bool overwriteRedefinition) const; + /// bool operator==(MacroData const & x) const { + updateData(); + x.updateData(); return definition_ == x.definition_ && numargs_ == x.numargs_ && display_ == x.display_ @@ -78,24 +98,49 @@ public: private: /// - docstring definition_; + void queryData(MathMacroTemplate const & macro) const; /// - size_t numargs_; + void updateData() const; /// - docstring display_; + Buffer const * buffer_; + /// The position of the definition in the buffer. + /// There is no guarantee it stays valid if the buffer + /// changes. But it (normally) exists only until the + /// next Buffer::updateMacros call where new MacroData + /// objects are created for each macro definition. + /// In the worst case, it is invalidated and the MacroData + /// returns its defaults values and the user sees unfolded + /// macros. + mutable DocIterator pos_; /// - std::string requires_; + mutable bool queried_; /// - mutable int lockCount_; + mutable docstring definition_; + /// + mutable size_t numargs_; /// - bool redefinition_; + mutable docstring display_; /// - size_t optionals_; + mutable std::string requires_; /// - std::vector defaults_; + mutable size_t optionals_; + /// + mutable std::vector defaults_; + /// + mutable int lockCount_; + /// + mutable bool redefinition_; + /// + mutable MacroType type_; }; +/// +class MacroNameSet : public std::set {}; +/// +class MacroSet : public std::set {}; + + /// A lookup table of macro definitions. /** * This contains a table of "global" macros that are always accessible, @@ -107,15 +152,15 @@ class MacroTable : public std::map { public: /// Parse full "\\def..." or "\\newcommand..." or ... - void insert(docstring const & definition, std::string const &); + iterator insert(Buffer * buf, docstring const & definition, std::string const &); /// Insert pre-digested macro definition - void insert(docstring const & name, MacroData const & data); - /// Do we have a macro by that name? - bool has(docstring const & name) const; + iterator insert(docstring const & name, MacroData const & data); /// - MacroData const & get(docstring const & name) const; + MacroData const * get(docstring const & name) const; /// void dump(); + /// + void getMacroNames(std::set & names) const; /// the global list static MacroTable & globalMacros(); @@ -132,24 +177,17 @@ public: **/ class MacroContext { public: - /// construct context for insets in par (not including the ones defined in par itself) - MacroContext(Buffer const & buf, Paragraph const & par); + /// construct context for the insets at pos + MacroContext(Buffer const * buf, DocIterator const & pos); - /// Look for macro - bool has(docstring const & name) const; /// Lookup macro - MacroData const & get(docstring const & name) const; - - /// Insert pre-digested macro definition - void insert(docstring const & name, MacroData const & data); + MacroData const * get(docstring const & name) const; private: - /// context local macros - MacroTable macros_; /// - Buffer const & buf_; + Buffer const * buf_; /// - Paragraph const & par_; + DocIterator const & pos_; }; } // namespace lyx