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