X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMacroTable.h;h=5fa88cee2b2e43eb996126af9d803f8b4aabe3fc;hb=11a6b3c4c7a031fd3776f53c9c43f62116933cea;hp=25664a1820e7323fd605656e9d621b38a3c07e12;hpb=897436efbb9bd641b61467d185a2dfae9839e575;p=lyx.git

diff --git a/src/mathed/MacroTable.h b/src/mathed/MacroTable.h
index 25664a1820..5fa88cee2b 100644
--- a/src/mathed/MacroTable.h
+++ b/src/mathed/MacroTable.h
@@ -5,6 +5,7 @@
  * Licence details can be found in the file COPYING.
  *
  * \author André Pönitz
+ * \author Stefan Schimanski
  *
  * Full author contact details are available in file CREDITS.
  */
@@ -12,71 +13,136 @@
 #ifndef MATH_MACROTABLE_H
 #define MATH_MACROTABLE_H
 
-#include "support/docstring.h"
+#include "DocIterator.h"
 
-#include <boost/assert.hpp>
+#include "support/docstring.h"
+#include "support/types.h"
 
 #include <map>
 #include <vector>
 
 namespace lyx {
 
+class Buffer;
 class MathData;
+class MathMacroTemplate;
+class Paragraph;
+
+
+enum MacroType {
+	MacroTypeNewcommand,
+	MacroTypeDef
+};
+
 
 ///
 class MacroData {
 public:
-	///
+	/// Constructor to make STL containers happy
 	MacroData();
+	/// Create lazy MacroData which only queries the macro template when needed
+	MacroData(Buffer const & buf, DocIterator const & pos);
+	/// Create non-lazy MacroData which directly queries the macro template
+	MacroData(MathMacroTemplate const & macro);
+
 	///
-	MacroData(docstring const & def, int nargs, docstring const & disp, std::string const &);
-	///
-	docstring def() const { return def_; }
-	///
-	docstring disp() const { return disp_; }
+	docstring const & definition() const { updateData(); return definition_; }
 	///
-	int numargs() const { return numargs_; }
-	/// replace #1,#2,... by given MathAtom 0,1,..
+	docstring const & display() const { updateData(); return display_; }
+	/// arity including optional arguments (if there is any)
+	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;
+	/// 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 { updateData(); return requires_; }
 	///
-	std::string & requires() { return requires_; }
-	/// lock while being drawn
+	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;
+	
+	///
+	bool redefinition() const { return redefinition_; }
 	///
-	void unlock() const { --lockCount_; BOOST_ASSERT(lockCount_ >= 0); }
+	void setRedefinition(bool redefined) { redefinition_ = redefined; }
+
+	///
+	MacroType type() const { return type_; }
+	///
+	MacroType & type() { return type_; }
+	
+	/// output as TeX macro, only works for lazy MacroData!!!
+	void write(odocstream & os, bool overwriteRedefinition) const;
 
 	///
 	bool operator==(MacroData const & x) const {
-		return def_ == x.def_ &&
-			numargs_ == x.numargs_ &&
-			disp_ == x.disp_ &&
-			requires_ == x.requires_;
+		updateData();
+		x.updateData();
+		return definition_ == x.definition_ 
+			&& numargs_ == x.numargs_
+			&& display_ == x.display_
+			&& requires_ == x.requires_
+			&& optionals_ == x.optionals_
+			&& defaults_ == x.defaults_;
 	}
 	///
 	bool operator!=(MacroData const & x) const { return !operator==(x); }
 
 private:
 	///
-	docstring def_;
+	void queryData(MathMacroTemplate 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 
+	/// 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_;
+	///
+	mutable bool queried_;
 	///
-	int numargs_;
+	mutable docstring definition_;
 	///
-	docstring disp_;
+	mutable size_t numargs_;
 	///
-	std::string requires_;
+	mutable docstring display_;
+	///
+	mutable std::string requires_;
+	///
+	mutable size_t optionals_;
+	///
+	mutable std::vector<docstring> defaults_;
 	///
 	mutable int lockCount_;
+	///
+	mutable bool redefinition_;
+	///
+	mutable MacroType type_;
 };
 
-
-// This contains a table of "global" macros that are always accessible,
-// either because they implement a feature of standard LaTeX or some
-// hack to display certain contents nicely.
-
+	
+/// A lookup table of macro definitions.
+/**
+ * This contains a table of "global" macros that are always accessible,
+ * either because they implement a feature of standard LaTeX or some
+ * hack to display certain contents nicely.
+ *
+ **/
 class MacroTable : public std::map<docstring, MacroData>
 {
 public:
@@ -84,20 +150,39 @@ public:
 	void insert(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;
 	///
-	MacroData const & get(docstring const & name) const;
+	MacroData const * get(docstring const & name) const;
 	///
 	void dump();
 
 	/// the global list
 	static MacroTable & globalMacros();
-	/// the local list hack
-	//static MacroTable & localMacros();
 };
 
 
+/// A context to lookup macros at a certain position in a buffer.
+/**
+ * The MacroContext is used during metrics calculation to resolve
+ * macro instances according to the position of them in the buffer
+ * document. Only macro definition in front of the macro instance
+ * are visible and are resolved.
+ *
+ **/
+class MacroContext {
+public:
+	/// construct context for the insets at pos
+	MacroContext(Buffer const & buf, DocIterator const & pos);
+	
+	/// Lookup macro
+	MacroData const * get(docstring const & name) const;
+	
+private:
+	///
+	Buffer const & buf_;
+	///
+	DocIterator const & pos_;
+};
+
 } // namespace lyx
 
 #endif