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