#include "DocIterator.h"
#include "support/docstring.h"
-#include "support/types.h"
#include <map>
#include <set>
class Buffer;
class MathData;
-class MathMacroTemplate;
-class Paragraph;
+class InsetMathMacroTemplate;
+class latexkeys;
enum MacroType {
MacroTypeNewcommand,
+ MacroTypeNewcommandx,
MacroTypeDef
};
-///
-class MacroNameSet : public std::set<docstring> {};
-
///
class MacroData {
public:
/// Constructor to make STL containers happy
- MacroData();
+ explicit MacroData(Buffer const * buf = 0);
/// Create lazy MacroData which only queries the macro template when needed
- MacroData(Buffer const & buf, DocIterator const & pos);
+ MacroData(Buffer const * buf, DocIterator const & pos);
/// Create non-lazy MacroData which directly queries the macro template
- MacroData(MathMacroTemplate const & macro);
+ MacroData(Buffer const * buf, InsetMathMacroTemplate const & macro);
///
docstring const & definition() const { updateData(); return definition_; }
size_t numargs() const { updateData(); return numargs_; }
/// replace #1,#2,... by given MathAtom 0,1,.., _including_ the possible
/// optional argument
- void expand(std::vector<MathData> const & from, MathData & to) const;
+ /// \return whether anything was expanded
+ bool expand(std::vector<MathData> const & from, MathData & to) const;
/// number of optional arguments
size_t optionals() const;
///
std::vector<docstring> const & defaults() const;
///
- std::string const & requires() const { updateData(); return requires_; }
+ std::string const required() const;
+ ///
+ bool hidden() const;
+ ///
+ docstring const xmlname() const;
+ ///
+ char const * MathMLtype() const;
///
- std::string & requires() { updateData(); return requires_; }
-
+ latexkeys const * symbol() const { return sym_; }
+ ///
+ void setSymbol(latexkeys const * sym) { sym_ = sym; }
+ ///
+ DocIterator const & pos() const { return pos_; }
+
/// 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;
-
- ///
- bool redefinition() const { return redefinition_; }
- ///
- void setRedefinition(bool redefined) { redefinition_ = redefined; }
///
- MacroType type() const { return type_; }
+ bool redefinition() const { updateData(); return redefinition_; }
+
///
- MacroType & type() { return type_; }
-
+ MacroType type() const { updateData(); return type_; }
+
/// output as TeX macro, only works for lazy MacroData!!!
- void write(odocstream & os, bool overwriteRedefinition) const;
+ int write(odocstream & os, bool overwriteRedefinition) const;
///
bool operator==(MacroData const & x) const {
updateData();
x.updateData();
- return definition_ == x.definition_
+ return definition_ == x.definition_
&& numargs_ == x.numargs_
&& display_ == x.display_
- && requires_ == x.requires_
+ && sym_ == x.sym_
&& optionals_ == x.optionals_
&& defaults_ == x.defaults_;
}
private:
///
- void queryData(MathMacroTemplate const & macro) const;
+ void queryData(InsetMathMacroTemplate const & macro) const;
///
void updateData() const;
///
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
+ /// 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
+ /// In the worst case, it is invalidated and the MacroData
/// returns its defaults values and the user sees unfolded
/// macros.
mutable DocIterator pos_;
///
- mutable bool queried_;
+ mutable bool queried_ = false;
///
mutable docstring definition_;
///
- mutable size_t numargs_;
+ mutable size_t numargs_ = 0;
///
mutable docstring display_;
///
- mutable std::string requires_;
+ latexkeys const * sym_ = nullptr;
///
- mutable size_t optionals_;
+ mutable size_t optionals_ = 0;
///
mutable std::vector<docstring> defaults_;
///
- mutable int lockCount_;
+ mutable int lockCount_ = 0;
///
- mutable bool redefinition_;
+ mutable bool redefinition_ = false;
///
- mutable MacroType type_;
+ mutable MacroType type_ = MacroTypeNewcommand;
};
-
+
+///
+class MacroNameSet : public std::set<docstring> {};
+///
+class MacroSet : public std::set<MacroData const *> {};
+
+
/// A lookup table of macro definitions.
/**
* This contains a table of "global" macros that are always accessible,
{
public:
/// Parse full "\\def..." or "\\newcommand..." or ...
- void insert(docstring const & definition, std::string const &);
+ iterator insert(Buffer * buf, docstring const & definition);
/// Insert pre-digested macro definition
- void insert(docstring const & name, MacroData const & data);
+ iterator insert(docstring const & name, MacroData const & data);
///
MacroData const * get(docstring const & name) const;
///
void dump();
///
- void getMacroNames(std::set<docstring> & names) const;
+ void getMacroNames(std::set<docstring> & names, bool gethidden) const;
/// the global list
static MacroTable & globalMacros();
class MacroContext {
public:
/// construct context for the insets at pos
- MacroContext(Buffer const & buf, DocIterator const & pos);
-
+ MacroContext(Buffer const * buf, DocIterator const & pos);
+
/// Lookup macro
MacroData const * get(docstring const & name) const;
-
+
private:
///
- Buffer const & buf_;
+ Buffer const * buf_;
///
DocIterator const & pos_;
};
projects / lyx.git / blobdiff