kdbg/typetable.h

   1 /*
   2  * Copyright Johannes Sixt
   3  * This file is licensed under the GNU General Public License Version 2.
   4  * See the file COPYING in the toplevel directory of the source directory.
   5  */
   6
   7 #include <qdict.h>
   8 #include <qstring.h>
   9 #include <qregexp.h>
  10 #include <qstringlist.h>
  11 #include <map>
  12
  13 class KConfigBase;
  14
  15 /**
  16  * The maximum number of sub-expressions that may appear in a single struct
  17  * value.
  18  */
  19 const int typeInfoMaxExpr = 5;
  20
  21
  22 struct TypeInfo
  23 {
  24     TypeInfo(const QString& displayString);
  25     ~TypeInfo();
  26
  27     /**
  28      * The number of sub-expressions that need to be evaluated to get the
  29      * struct value.
  30      */
  31     int m_numExprs;
  32     /**
  33      * This array contains the various parts which glue together the
  34      * sub-expressions. The entries in this array are the parts that appear
  35      * between the percent signs '%' of the display expression; hence,
  36      * there is one part more than there are sub-expressions.
  37      */
  38     QString m_displayString[typeInfoMaxExpr+1];
  39     /**
  40      * This is a list of partial expressions. Each contains one or more \%s,
  41      * which will be replaced by the parent expression. The results are
  42      * substituted for the percent signs in m_displayString.
  43      */
  44     QString m_exprStrings[typeInfoMaxExpr];
  45     /**
  46      * This is a list of guard expressions. Each contains one or more \%s,
  47      * which will be replaced by the parent expression, or is empty. If the
  48      * evaluation of the resulting expression returns an error, the
  49      * corresponding expression from m_exprStrings is not evaluated. (This
  50      * is used to guard function calls.)
  51      */
  52     QString m_guardStrings[typeInfoMaxExpr];
  53     /**
  54      * This is the type name including template arguments that contain a
  55      * pattern: A single '*' as template parameter matches one template
  56      * argument, except that a '*' as the last template parameter matches
  57      * all remaining template argument.
  58      */
  59     QString m_templatePattern;
  60     /**
  61      * Returns a pointer to a TypeInfo that identifies wchar_t
  62      */
  63     static TypeInfo* wchartType() { return &m_wchartType; }
  64     /**
  65      * Gets a pointer to a TypeInfo that means: "I don't know the type"
  66      */
  67     static TypeInfo* unknownType() { return &m_unknownType; }
  68
  69 protected:
  70     static TypeInfo m_wchartType;
  71     static TypeInfo m_unknownType;
  72 };
  73
  74 class TypeTable
  75 {
  76 public:
  77     TypeTable();
  78     ~TypeTable();
  79
  80     typedef std::map<QString,TypeInfo*> TypeMap;
  81
  82     /**
  83      * Load all known type libraries.
  84      */
  85     static void initTypeLibraries();
  86
  87     /**
  88      * Copy type infos to the specified dictionary.
  89      */
  90     void copyTypes(QDict<TypeInfo>& dict);
  91
  92     /**
  93      * Returns the template types
  94      */
  95     const TypeMap& templates() const { return m_templates; }
  96
  97     /**
  98      * Does the file name match this library?
  99      */
 100     bool matchFileName(const char* fileName) {
 101         return m_shlibNameRE.match(fileName) >= 0;
 102     }
 103
 104     /**
 105      * Is the specified builtin feature enabled in this type library?
 106      */
 107     bool isEnabledBuiltin(const QString& feature) const;
 108
 109     /**
 110      * Returns the command to print the QString data.
 111      */
 112     const char* printQStringDataCmd() const { return m_printQStringDataCmd; }
 113
 114 protected:
 115     /**
 116      * Loads the structure type information from the configuration files.
 117      */
 118     static void loadTypeTables();
 119     void loadFromFile(const QString& fileName);
 120     void readType(KConfigBase& cf, const QString& type);
 121     QDict<TypeInfo> m_typeDict;
 122     QDict<TypeInfo> m_aliasDict;
 123     TypeMap m_templates;
 124     QString m_displayName;
 125     QRegExp m_shlibNameRE;
 126     QStringList m_enabledBuiltins;
 127     char* m_printQStringDataCmd;
 128 };
 129
 130
 131 /**
 132  * This table keeps only references to the global type table. It is set up
 133  * once per program.
 134  */
 135 class ProgramTypeTable
 136 {
 137 public:
 138     ProgramTypeTable();
 139     ~ProgramTypeTable();
 140
 141     /**
 142      * Load types belonging to the specified libraries.
 143      */
 144     void loadLibTypes(const QStringList& libs);
 145
 146     /**
 147      * Load types belonging to the specified type table
 148      */
 149     void loadTypeTable(TypeTable* table);
 150
 151     /**
 152      * Lookup a structure type.
 153      *
 154      * If the type is unknown, 0 is returned.
 155      */
 156     TypeInfo* lookup(QString type);
 157
 158     /**
 159      * Adds a new alias for a type name.
 160      */
 161     void registerAlias(const QString& name, TypeInfo* type);
 162
 163     /**
 164      * Tells whether we use built-in support to understand QStrings.
 165      */
 166     bool parseQt2QStrings() const { return m_parseQt2QStrings; }
 167
 168     /**
 169      * Tells whether QChar are defined like in Qt3.
 170      */
 171     bool qCharIsShort() const { return m_QCharIsShort; }
 172
 173     /**
 174      * Returns the command to print the QString data.
 175      */
 176     const char* printQStringDataCmd() const { return m_printQStringDataCmd; }
 177
 178 protected:
 179     QDict<TypeInfo> m_types;
 180     QDict<TypeInfo> m_aliasDict;
 181     struct TemplateInfo {
 182         QStringList templateArgs;
 183         TypeInfo* type;
 184     };
 185     typedef std::multimap<QString, TemplateInfo> TemplateMap;
 186     TemplateMap m_templates;    //!< one or more template patterns per template name
 187     static TemplateMap::value_type
 188                 template2Info(const TypeTable::TypeMap::value_type& tt);
 189     static QStringList splitTemplateArgs(const QString& t);
 190     bool m_parseQt2QStrings;
 191     bool m_QCharIsShort;
 192     const char* m_printQStringDataCmd;
 193 };