X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMacroTable.h;h=bc445d43974fef7f7314160a5a8f1f43ad2d4dd3;hb=cdc847fd304019a19425a0d5d9d42a556a937097;hp=709fd3b61fcc35a80f09ae7b0994d97b2286bf78;hpb=f09222007fdfaa35935b0b7576725ac338432790;p=lyx.git

diff --git a/src/mathed/MacroTable.h b/src/mathed/MacroTable.h
index 709fd3b61f..bc445d4397 100644
--- a/src/mathed/MacroTable.h
+++ b/src/mathed/MacroTable.h
@@ -13,62 +13,91 @@
 #ifndef MATH_MACROTABLE_H
 #define MATH_MACROTABLE_H
 
+#include "DocIterator.h"
+
 #include "support/docstring.h"
 
 #include <map>
+#include <set>
 #include <vector>
 
 namespace lyx {
 
 class Buffer;
 class MathData;
+class MathMacroTemplate;
 class Paragraph;
+class latexkeys;
+
+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<docstring> 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_; }
+	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 requires() const { return requires_; }
+	std::string const requires() const;
+	///
+	bool hidden() const;
+	///
+	docstring const xmlname() const;
 	///
-	std::string & requires() { return requires_; }
-	
+	char const * MathMLtype() const;
+	///
+	latexkeys const * symbol() const { return sym_; }
+	///
+	void setSymbol(latexkeys const * sym) { sym_ = sym; }
+	///
+	DocIterator const & pos() { 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_; }
+	bool redefinition() const { updateData(); return redefinition_; }
+
 	///
-	void setRedefinition(bool redefined) { redefinition_ = redefined; }
-	
+	MacroType type() const { updateData(); return type_; }
+
+	/// output as TeX macro, only works for lazy MacroData!!!
+	int write(odocstream & os, bool overwriteRedefinition) const;
+
 	///
 	bool operator==(MacroData const & x) const {
-		return definition_ == x.definition_ 
+		updateData();
+		x.updateData();
+		return definition_ == x.definition_
 			&& numargs_ == x.numargs_
 			&& display_ == x.display_
-			&& requires_ == x.requires_
+			&& sym_ == x.sym_
 			&& optionals_ == x.optionals_
 			&& defaults_ == x.defaults_;
 	}
@@ -77,24 +106,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_;
+	///
+	mutable docstring display_;
+	///
+	latexkeys const * sym_;
 	///
-	bool redefinition_;
+	mutable size_t optionals_;
 	///
-	size_t optionals_;
+	mutable std::vector<docstring> defaults_;
 	///
-	std::vector<docstring> defaults_;
+	mutable int lockCount_;
+	///
+	mutable bool redefinition_;
+	///
+	mutable MacroType type_;
 };
 
 
+///
+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,
@@ -106,15 +160,15 @@ class MacroTable : public std::map<docstring, MacroData>
 {
 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);
-	/// 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<docstring> & names, bool gethidden) const;
 
 	/// the global list
 	static MacroTable & globalMacros();
@@ -131,25 +185,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);
-	
-	/// Look for macro
-	bool has(docstring const & name) const;
+	/// construct context for the insets at pos
+	MacroContext(Buffer const * buf, DocIterator const & pos);
+
 	/// 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