src/mathed/MacroTable.h

   1 // -*- C++ -*-
   2 /**
   3  * \file MacroTable.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author André Pönitz
   8  * \author Stefan Schimanski
   9  *
  10  * Full author contact details are available in file CREDITS.
  11  */
  12
  13 #ifndef MATH_MACROTABLE_H
  14 #define MATH_MACROTABLE_H
  15
  16 #include "DocIterator.h"
  17
  18 #include "support/docstring.h"
  19
  20 #include <map>
  21 #include <set>
  22 #include <vector>
  23
  24 namespace lyx {
  25
  26 class Buffer;
  27 class MathData;
  28 class MathMacroTemplate;
  29 class Paragraph;
  30
  31 enum MacroType {
  32         MacroTypeNewcommand,
  33         MacroTypeNewcommandx,
  34         MacroTypeDef
  35 };
  36
  37 ///
  38 class MacroData {
  39 public:
  40         /// Constructor to make STL containers happy
  41         MacroData(Buffer * buf = 0);
  42         /// Create lazy MacroData which only queries the macro template when needed
  43         MacroData(Buffer * buf, DocIterator const & pos);
  44         /// Create non-lazy MacroData which directly queries the macro template
  45         MacroData(Buffer * buf, MathMacroTemplate const & macro);
  46
  47         ///
  48         docstring const & definition() const { updateData(); return definition_; }
  49         ///
  50         docstring const & display() const { updateData(); return display_; }
  51         /// arity including optional arguments (if there is any)
  52         size_t numargs() const { updateData(); return numargs_; }
  53         /// replace #1,#2,... by given MathAtom 0,1,.., _including_ the possible
  54         /// optional argument
  55         void expand(std::vector<MathData> const & from, MathData & to) const;
  56         /// number of optional arguments
  57         size_t optionals() const;
  58         ///
  59         std::vector<docstring> const & defaults() const;
  60         ///
  61         std::string const & requires() const { return requires_; }
  62         ///
  63         std::string & requires() { return requires_; }
  64
  65         /// lock while being drawn to avoid recursions
  66         int lock() const { return ++lockCount_; }
  67         /// is it being drawn?
  68         bool locked() const { return lockCount_ != 0; }
  69         ///
  70         void unlock() const;
  71
  72         ///
  73         bool redefinition() const { updateData(); return redefinition_; }
  74
  75         ///
  76         MacroType type() const { updateData(); return type_; }
  77
  78         /// output as TeX macro, only works for lazy MacroData!!!
  79         int write(odocstream & os, bool overwriteRedefinition) const;
  80
  81         ///
  82         bool operator==(MacroData const & x) const {
  83                 updateData();
  84                 x.updateData();
  85                 return definition_ == x.definition_
  86                         && numargs_ == x.numargs_
  87                         && display_ == x.display_
  88                         && requires_ == x.requires_
  89                         && optionals_ == x.optionals_
  90                         && defaults_ == x.defaults_;
  91         }
  92         ///
  93         bool operator!=(MacroData const & x) const { return !operator==(x); }
  94
  95 private:
  96         ///
  97         void queryData(MathMacroTemplate const & macro) const;
  98         ///
  99         void updateData() const;
 100         ///
 101         Buffer const * buffer_;
 102         /// The position of the definition in the buffer.
 103         /// There is no guarantee it stays valid if the buffer
 104         /// changes. But it (normally) exists only until the
 105         /// next Buffer::updateMacros call where new MacroData
 106         /// objects are created for each macro definition.
 107         /// In the worst case, it is invalidated and the MacroData
 108         /// returns its defaults values and the user sees unfolded
 109         /// macros.
 110         mutable DocIterator pos_;
 111         ///
 112         mutable bool queried_;
 113         ///
 114         mutable docstring definition_;
 115         ///
 116         mutable size_t numargs_;
 117         ///
 118         mutable docstring display_;
 119         ///
 120         std::string requires_;
 121         ///
 122         mutable size_t optionals_;
 123         ///
 124         mutable std::vector<docstring> defaults_;
 125         ///
 126         mutable int lockCount_;
 127         ///
 128         mutable bool redefinition_;
 129         ///
 130         mutable MacroType type_;
 131 };
 132
 133
 134 ///
 135 class MacroNameSet : public std::set<docstring> {};
 136 ///
 137 class MacroSet : public std::set<MacroData const *> {};
 138
 139
 140 /// A lookup table of macro definitions.
 141 /**
 142  * This contains a table of "global" macros that are always accessible,
 143  * either because they implement a feature of standard LaTeX or some
 144  * hack to display certain contents nicely.
 145  *
 146  **/
 147 class MacroTable : public std::map<docstring, MacroData>
 148 {
 149 public:
 150         /// Parse full "\\def..." or "\\newcommand..." or ...
 151         iterator insert(Buffer * buf, docstring const & definition, std::string const &);
 152         /// Insert pre-digested macro definition
 153         iterator insert(docstring const & name, MacroData const & data);
 154         ///
 155         MacroData const * get(docstring const & name) const;
 156         ///
 157         void dump();
 158         ///
 159         void getMacroNames(std::set<docstring> & names) const;
 160
 161         /// the global list
 162         static MacroTable & globalMacros();
 163 };
 164
 165
 166 /// A context to lookup macros at a certain position in a buffer.
 167 /**
 168  * The MacroContext is used during metrics calculation to resolve
 169  * macro instances according to the position of them in the buffer
 170  * document. Only macro definition in front of the macro instance
 171  * are visible and are resolved.
 172  *
 173  **/
 174 class MacroContext {
 175 public:
 176         /// construct context for the insets at pos
 177         MacroContext(Buffer const * buf, DocIterator const & pos);
 178
 179         /// Lookup macro
 180         MacroData const * get(docstring const & name) const;
 181
 182 private:
 183         ///
 184         Buffer const * buf_;
 185         ///
 186         DocIterator const & pos_;
 187 };
 188
 189 } // namespace lyx
 190
 191 #endif