kdbg/typetable.cpp

   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 <qdir.h>
   8 #include <qptrlist.h>
   9 #include <kglobal.h>
  10 #include <kstddirs.h>
  11 #include <ksimpleconfig.h>
  12 #ifdef HAVE_CONFIG_H
  13 #include "config.h"
  14 #endif
  15 #include "typetable.h"
  16 #include "mydebug.h"
  17
  18 //! the TypeTables of all known libraries
  19 static QList<TypeTable> typeTables;
  20 bool typeTablesInited = false;
  21
  22
  23 //! an indentifier for wchar_t
  24 TypeInfo TypeInfo::m_wchartType("");
  25 //! the unknown type
  26 TypeInfo TypeInfo::m_unknownType("");
  27
  28
  29 void TypeTable::initTypeLibraries()
  30 {
  31     if (!typeTablesInited) {
  32         TypeTable::loadTypeTables();
  33     }
  34 }
  35
  36 void TypeTable::loadTypeTables()
  37 {
  38     typeTablesInited = true;
  39
  40     const QStringList files = KGlobal::dirs()->findAllResources("types", "*.kdbgtt",
  41                         false, true);
  42
  43     if (files.isEmpty()) {
  44         TRACE("no type tables found");
  45         return;
  46     }
  47
  48     QString fileName;
  49     for (QValueListConstIterator<QString> p = files.begin(); p != files.end(); ++p) {
  50         fileName = *p;
  51         TypeTable* newTable = new TypeTable;
  52         newTable->loadFromFile(fileName);
  53         typeTables.append(newTable);
  54     }
  55 }
  56
  57
  58 TypeTable::TypeTable() :
  59         m_printQStringDataCmd(0)
  60 {
  61     m_typeDict.setAutoDelete(true);
  62     // aliasDict keeps only pointers to items into typeDict
  63     m_aliasDict.setAutoDelete(false);
  64 }
  65
  66 TypeTable::~TypeTable()
  67 {
  68     delete[] m_printQStringDataCmd;
  69 }
  70
  71
  72 static const char TypeTableGroup[] = "Type Table";
  73 static const char LibDisplayName[] = "LibDisplayName";
  74 static const char ShlibRE[] = "ShlibRE";
  75 static const char EnableBuiltin[] = "EnableBuiltin";
  76 static const char PrintQStringCmd[] = "PrintQStringCmd";
  77 static const char TypesEntryFmt[] = "Types%d";
  78 static const char DisplayEntry[] = "Display";
  79 static const char AliasEntry[] = "Alias";
  80 static const char ExprEntryFmt[] = "Expr%d";
  81 static const char FunctionGuardEntryFmt[] = "FunctionGuard%d";
  82
  83
  84 void TypeTable::loadFromFile(const QString& fileName)
  85 {
  86     TRACE("reading file " + fileName);
  87     KSimpleConfig cf(fileName, true);   /* read-only */
  88
  89     /*
  90      * Read library name and properties.
  91      */
  92     cf.setGroup(TypeTableGroup);
  93     m_displayName = cf.readEntry(LibDisplayName);
  94     if (m_displayName.isEmpty()) {
  95         // use file name instead
  96         QFileInfo fi(fileName);
  97         m_displayName = fi.baseName(true);
  98     }
  99
 100     m_shlibNameRE = QRegExp(cf.readEntry(ShlibRE));
 101     m_enabledBuiltins = cf.readListEntry(EnableBuiltin);
 102
 103     QString printQString = cf.readEntry(PrintQStringCmd);
 104     const char* ascii = printQString.ascii();
 105     if (ascii == 0)
 106         ascii = "";
 107     m_printQStringDataCmd = new char[strlen(ascii)+1];
 108     strcpy(m_printQStringDataCmd, ascii);
 109
 110     /*
 111      * Get the types. We search for entries of kind Types1, Types2, etc.
 112      * because a single entry Types could get rather long for large
 113      * libraries.
 114      */
 115     QString typesEntry;
 116     for (int i = 1; ; i++) {
 117         // next bunch of types
 118         cf.setGroup(TypeTableGroup);
 119         typesEntry.sprintf(TypesEntryFmt, i);
 120         if (!cf.hasKey(typesEntry))
 121             break;
 122
 123         QStringList typeNames = cf.readListEntry(typesEntry, ',');
 124
 125         // now read them
 126         QString alias;
 127         for (QStringList::iterator it = typeNames.begin(); it != typeNames.end(); ++it)
 128         {
 129             cf.setGroup(*it);
 130             // check if this is an alias
 131             alias = cf.readEntry(AliasEntry);
 132             if (alias.isEmpty()) {
 133                 readType(cf, *it);
 134             } else {
 135                 // look up the alias type and insert it
 136                 TypeInfo* info = m_typeDict[alias];
 137                 if (info == 0) {
 138                     TRACE(*it + ": alias " + alias + " not found");
 139                 } else {
 140                     m_aliasDict.insert(alias, info);
 141                     TRACE(*it + ": alias " + alias);
 142                 }
 143             }
 144         }
 145     } // for all Types%d
 146 }
 147
 148 void TypeTable::readType(KConfigBase& cf, const QString& type)
 149 {
 150     // the display string
 151     QString expr = cf.readEntry(DisplayEntry);
 152
 153     TypeInfo* info = new TypeInfo(expr);
 154     if (info->m_numExprs == 0) {
 155         TRACE("bogus type " + type + ": no %% in Display: " + expr);
 156         delete info;
 157         return;
 158     }
 159
 160     // Expr1, Expr2, etc...
 161     QString exprEntry;
 162     QString funcGuardEntry;
 163     for (int j = 0; j < info->m_numExprs; j++) {
 164         exprEntry.sprintf(ExprEntryFmt, j+1);
 165         expr = cf.readEntry(exprEntry);
 166         info->m_exprStrings[j] = expr;
 167
 168         funcGuardEntry.sprintf(FunctionGuardEntryFmt, j+1);
 169         expr = cf.readEntry(funcGuardEntry);
 170         info->m_guardStrings[j] = expr;
 171     }
 172
 173     // add the new type
 174     m_typeDict.insert(type, info);
 175     TRACE(type + QString().sprintf(": %d exprs", info->m_numExprs));
 176 }
 177
 178 void TypeTable::copyTypes(QDict<TypeInfo>& dict)
 179 {
 180     for (QDictIterator<TypeInfo> it = m_typeDict; it != 0; ++it) {
 181         dict.insert(it.currentKey(), it);
 182     }
 183     for (QDictIterator<TypeInfo> it = m_aliasDict; it != 0; ++it) {
 184         dict.insert(it.currentKey(), it);
 185     }
 186 }
 187
 188 bool TypeTable::isEnabledBuiltin(const QString& feature) const
 189 {
 190     return m_enabledBuiltins.find(feature) != m_enabledBuiltins.end();
 191 }
 192
 193 TypeInfo::TypeInfo(const QString& displayString)
 194 {
 195     // decompose the input into the parts
 196     int i = 0;
 197     int startIdx = 0;
 198     int idx;
 199     while (i < typeInfoMaxExpr &&
 200            (idx = displayString.find('%', startIdx)) >= 0)
 201     {
 202         m_displayString[i] = displayString.mid(startIdx, idx-startIdx);
 203         startIdx = idx+1;
 204         i++;
 205     }
 206     m_numExprs = i;
 207     /*
 208      * Remaining string; note that there's one more display string than
 209      * sub-expressions.
 210      */
 211     m_displayString[i] = displayString.right(displayString.length()-startIdx);
 212 }
 213
 214 TypeInfo::~TypeInfo()
 215 {
 216 }
 217
 218
 219 ProgramTypeTable::ProgramTypeTable() :
 220         m_parseQt2QStrings(false),
 221         m_QCharIsShort(false),
 222         m_printQStringDataCmd(0)
 223 {
 224     m_types.setAutoDelete(false);       /* paranoia */
 225     m_aliasDict.setAutoDelete(false);   /* paranoia */
 226 }
 227
 228 ProgramTypeTable::~ProgramTypeTable()
 229 {
 230 }
 231
 232 void ProgramTypeTable::clear()
 233 {
 234     m_types.clear();
 235 }
 236
 237 void ProgramTypeTable::loadTypeTable(TypeTable* table)
 238 {
 239     table->copyTypes(m_types);
 240     // check whether to enable builtin QString support
 241     if (!m_parseQt2QStrings) {
 242         m_parseQt2QStrings = table->isEnabledBuiltin("QString::Data");
 243     }
 244     if (!m_QCharIsShort) {
 245         m_QCharIsShort = table->isEnabledBuiltin("QCharIsShort");
 246     }
 247     if (!m_printQStringDataCmd && *table->printQStringDataCmd()) {
 248         m_printQStringDataCmd = table->printQStringDataCmd();
 249     }
 250 }
 251
 252 TypeInfo* ProgramTypeTable::lookup(const QString& type)
 253 {
 254     TypeInfo* result = m_types[type];
 255     if (result == 0) {
 256         result = m_aliasDict[type];
 257     }
 258     return result;
 259 }
 260
 261 void ProgramTypeTable::registerAlias(const QString& name, TypeInfo* type)
 262 {
 263     ASSERT(lookup(name) == 0 || lookup(name) == type);
 264     m_aliasDict.insert(name, type);
 265 }
 266
 267 void ProgramTypeTable::loadLibTypes(const QStrList& libs)
 268 {
 269     QStrListIterator it = libs;
 270
 271     /*
 272      * We use a copy of the list of known libraries, from which we delete
 273      * those libs that we already have added. This way we avoid to load a
 274      * library twice.
 275      */
 276     QList<TypeTable> allTables = typeTables;    /* shallow copy! */
 277     allTables.setAutoDelete(false);     /* important! */
 278
 279     for (; it && allTables.count() > 0; ++it)
 280     {
 281         // look up the library
 282     repeatLookup:;
 283         for (TypeTable* t = allTables.first(); t != 0; t = allTables.next())
 284         {
 285             if (t->matchFileName(it))
 286             {
 287                 TRACE("adding types for " + QString(it));
 288                 loadTypeTable(t);
 289                 // remove the table
 290                 allTables.remove();
 291                 /*
 292                  * continue the search (due to remove's unpredictable
 293                  * behavior of setting the current item we simply go
 294                  * through the whole list again)
 295                  */
 296                 goto repeatLookup;
 297             }
 298         }
 299     }
 300 }