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         int slash = fileName.findRev('\\');
  97         m_displayName =
  98             slash >= 0 ? fileName.mid(slash+1, fileName.length()) : fileName;
  99         int dot = m_displayName.findRev('.');
 100         if (dot > 0) {
 101             m_displayName.truncate(dot);
 102         }
 103     }
 104
 105     m_shlibNameRE = QRegExp(cf.readEntry(ShlibRE));
 106     cf.readListEntry(EnableBuiltin, m_enabledBuiltins);
 107
 108     QString printQString = cf.readEntry(PrintQStringCmd);
 109     const char* ascii = printQString.ascii();
 110     if (ascii == 0)
 111         ascii = "";
 112     m_printQStringDataCmd = new char[strlen(ascii)+1];
 113     strcpy(m_printQStringDataCmd, ascii);
 114
 115     /*
 116      * Get the types. We search for entries of kind Types1, Types2, etc.
 117      * because a single entry Types could get rather long for large
 118      * libraries.
 119      */
 120     QStrList typeNames;
 121     QString typesEntry;
 122     for (int i = 1; ; i++) {
 123         // next bunch of types
 124         cf.setGroup(TypeTableGroup);
 125         typesEntry.sprintf(TypesEntryFmt, i);
 126         if (!cf.hasKey(typesEntry))
 127             break;
 128         cf.readListEntry(typesEntry, typeNames, ',');
 129
 130         // now read them
 131         QString alias;
 132         for (QListIterator<char> it(typeNames); it != 0; ++it) {
 133             cf.setGroup(it.current());
 134             // check if this is an alias
 135             alias = cf.readEntry(AliasEntry);
 136             if (alias.isEmpty()) {
 137                 readType(cf, it);
 138             } else {
 139                 // look up the alias type and insert it
 140                 TypeInfo* info = m_typeDict[alias];
 141                 if (info == 0) {
 142                     TRACE(QString().sprintf("<%s>: alias %s not found",
 143                                             it.operator char*(), alias.data()));
 144                 } else {
 145                     m_aliasDict.insert(alias, info);
 146                     TRACE(QString().sprintf("<%s>: alias <%s>",
 147                                             it.operator char*(), alias.data()));
 148                 }
 149             }
 150         }
 151     } // for all Types%d
 152 }
 153
 154 void TypeTable::readType(KConfigBase& cf, const char* type)
 155 {
 156     // the display string
 157     QString expr = cf.readEntry(DisplayEntry);
 158
 159     TypeInfo* info = new TypeInfo(expr);
 160     if (info->m_numExprs == 0) {
 161         TRACE(QString().sprintf("bogus type %s: no %% in Display: '%s'",
 162                                 type, expr.data()));
 163         delete info;
 164         return;
 165     }
 166
 167     // Expr1, Expr2, etc...
 168     QString exprEntry;
 169     QString funcGuardEntry;
 170     for (int j = 0; j < info->m_numExprs; j++) {
 171         exprEntry.sprintf(ExprEntryFmt, j+1);
 172         expr = cf.readEntry(exprEntry);
 173         info->m_exprStrings[j] = expr;
 174
 175         funcGuardEntry.sprintf(FunctionGuardEntryFmt, j+1);
 176         expr = cf.readEntry(funcGuardEntry);
 177         info->m_guardStrings[j] = expr;
 178     }
 179
 180     // add the new type
 181     m_typeDict.insert(type, info);
 182     TRACE(QString().sprintf("<%s>: %d exprs", type,
 183                             info->m_numExprs));
 184 }
 185
 186 void TypeTable::copyTypes(QDict<TypeInfo>& dict)
 187 {
 188     for (QDictIterator<TypeInfo> it = m_typeDict; it != 0; ++it) {
 189         dict.insert(it.currentKey(), it);
 190     }
 191     for (QDictIterator<TypeInfo> it = m_aliasDict; it != 0; ++it) {
 192         dict.insert(it.currentKey(), it);
 193     }
 194 }
 195
 196 bool TypeTable::isEnabledBuiltin(const char* feature)
 197 {
 198     char* f = m_enabledBuiltins.first();
 199     while (f) {
 200         if (strcmp(feature, f) == 0)
 201             return true;
 202         f = m_enabledBuiltins.next();
 203     }
 204     return false;
 205 }
 206
 207 TypeInfo::TypeInfo(const QString& displayString)
 208 {
 209     // decompose the input into the parts
 210     int i = 0;
 211     int startIdx = 0;
 212     int idx;
 213     while (i < typeInfoMaxExpr &&
 214            (idx = displayString.find('%', startIdx)) >= 0)
 215     {
 216         m_displayString[i] = displayString.mid(startIdx, idx-startIdx);
 217         startIdx = idx+1;
 218         i++;
 219     }
 220     m_numExprs = i;
 221     /*
 222      * Remaining string; note that there's one more display string than
 223      * sub-expressions.
 224      */
 225     m_displayString[i] = displayString.right(displayString.length()-startIdx);
 226 }
 227
 228 TypeInfo::~TypeInfo()
 229 {
 230 }
 231
 232
 233 ProgramTypeTable::ProgramTypeTable() :
 234         m_parseQt2QStrings(false),
 235         m_QCharIsShort(false),
 236         m_printQStringDataCmd(0)
 237 {
 238     m_types.setAutoDelete(false);       /* paranoia */
 239     m_aliasDict.setAutoDelete(false);   /* paranoia */
 240 }
 241
 242 ProgramTypeTable::~ProgramTypeTable()
 243 {
 244 }
 245
 246 void ProgramTypeTable::clear()
 247 {
 248     m_types.clear();
 249 }
 250
 251 void ProgramTypeTable::loadTypeTable(TypeTable* table)
 252 {
 253     table->copyTypes(m_types);
 254     // check whether to enable builtin QString support
 255     if (!m_parseQt2QStrings) {
 256         m_parseQt2QStrings = table->isEnabledBuiltin("QString::Data");
 257     }
 258     if (!m_QCharIsShort) {
 259         m_QCharIsShort = table->isEnabledBuiltin("QCharIsShort");
 260     }
 261     if (!m_printQStringDataCmd && *table->printQStringDataCmd()) {
 262         m_printQStringDataCmd = table->printQStringDataCmd();
 263     }
 264 }
 265
 266 TypeInfo* ProgramTypeTable::lookup(const char* type)
 267 {
 268     TypeInfo* result = m_types[type];
 269     if (result == 0) {
 270         result = m_aliasDict[type];
 271     }
 272     return result;
 273 }
 274
 275 void ProgramTypeTable::registerAlias(const QString& name, TypeInfo* type)
 276 {
 277     ASSERT(lookup(name) == 0 || lookup(name) == type);
 278     m_aliasDict.insert(name, type);
 279 }
 280
 281 void ProgramTypeTable::loadLibTypes(const QStrList& libs)
 282 {
 283     QStrListIterator it = libs;
 284
 285     /*
 286      * We use a copy of the list of known libraries, from which we delete
 287      * those libs that we already have added. This way we avoid to load a
 288      * library twice.
 289      */
 290     QList<TypeTable> allTables = typeTables;    /* shallow copy! */
 291     allTables.setAutoDelete(false);     /* important! */
 292
 293     for (; it && allTables.count() > 0; ++it)
 294     {
 295         // look up the library
 296     repeatLookup:;
 297         for (TypeTable* t = allTables.first(); t != 0; t = allTables.next())
 298         {
 299             if (t->matchFileName(it))
 300             {
 301                 TRACE("adding types for " + QString(it));
 302                 loadTypeTable(t);
 303                 // remove the table
 304                 allTables.remove();
 305                 /*
 306                  * continue the search (due to remove's unpredictable
 307                  * behavior of setting the current item we simply go
 308                  * through the whole list again)
 309                  */
 310                 goto repeatLookup;
 311             }
 312         }
 313     }
 314 }