kdbg/typetable.h

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