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 <q3ptrlist.h>
   9 #include <kglobal.h>
  10 #include <kstandarddirs.h>
  11 #include <kconfig.h>
  12 #include <kconfiggroup.h>
  13 #include <list>
  14 #include <algorithm>
  15 #include <iterator>
  16 #include "typetable.h"
  17 #include "mydebug.h"
  18
  19 //! the TypeTables of all known libraries
  20 static std::list<TypeTable> typeTables;
  21 bool typeTablesInited = false;
  22
  23
  24 //! an indentifier for wchar_t
  25 TypeInfo TypeInfo::m_wchartType("");
  26 //! the unknown type
  27 TypeInfo TypeInfo::m_unknownType("");
  28
  29
  30 void TypeTable::initTypeLibraries()
  31 {
  32     if (!typeTablesInited) {
  33         TypeTable::loadTypeTables();
  34     }
  35 }
  36
  37 void TypeTable::loadTypeTables()
  38 {
  39     typeTablesInited = true;
  40
  41     const QStringList files = KGlobal::dirs()->findAllResources("types", "*.kdbgtt",
  42                         false, true);
  43
  44     if (files.isEmpty()) {
  45         TRACE("no type tables found");
  46         return;
  47     }
  48
  49     for (Q3ValueListConstIterator<QString> p = files.begin(); p != files.end(); ++p) {
  50         typeTables.push_back(TypeTable());
  51         typeTables.back().loadFromFile(*p);
  52     }
  53 }
  54
  55
  56 TypeTable::TypeTable() :
  57         m_printQStringDataCmd(0)
  58 {
  59     m_typeDict.setAutoDelete(true);
  60     // aliasDict keeps only pointers to items into typeDict
  61     m_aliasDict.setAutoDelete(false);
  62 }
  63
  64 TypeTable::~TypeTable()
  65 {
  66     delete[] m_printQStringDataCmd;
  67     while (!m_templates.empty()) {
  68         delete m_templates.begin()->second;
  69         m_templates.erase(m_templates.begin());
  70     }
  71 }
  72
  73
  74 static const char TypeTableGroup[] = "Type Table";
  75 static const char LibDisplayName[] = "LibDisplayName";
  76 static const char ShlibRE[] = "ShlibRE";
  77 static const char EnableBuiltin[] = "EnableBuiltin";
  78 static const char PrintQStringCmd[] = "PrintQStringCmd";
  79 static const char TypesEntryFmt[] = "Types%d";
  80 static const char DisplayEntry[] = "Display";
  81 static const char AliasEntry[] = "Alias";
  82 static const char TemplateEntry[] = "Template";
  83 static const char ExprEntryFmt[] = "Expr%d";
  84 static const char FunctionGuardEntryFmt[] = "FunctionGuard%d";
  85
  86
  87 void TypeTable::loadFromFile(const QString& fileName)
  88 {
  89     TRACE("reading file " + fileName);
  90     KConfig confFile(fileName, KConfig::SimpleConfig);
  91
  92     /*
  93      * Read library name and properties.
  94      */
  95     KConfigGroup cf = confFile.group(TypeTableGroup);
  96     m_displayName = cf.readEntry(LibDisplayName);
  97     if (m_displayName.isEmpty()) {
  98         // use file name instead
  99         QFileInfo fi(fileName);
 100         m_displayName = fi.baseName(true);
 101     }
 102
 103     m_shlibNameRE = QRegExp(cf.readEntry(ShlibRE));
 104     m_enabledBuiltins = cf.readEntry(EnableBuiltin, QStringList());
 105
 106     QString printQString = cf.readEntry(PrintQStringCmd);
 107     const char* ascii = printQString.ascii();
 108     if (ascii == 0)
 109         ascii = "";
 110     m_printQStringDataCmd = new char[strlen(ascii)+1];
 111     strcpy(m_printQStringDataCmd, ascii);
 112
 113     /*
 114      * Get the types. We search for entries of kind Types1, Types2, etc.
 115      * because a single entry Types could get rather long for large
 116      * libraries.
 117      */
 118     QString typesEntry;
 119     for (int i = 1; ; i++) {
 120         // next bunch of types
 121         KConfigGroup cf = confFile.group(TypeTableGroup);
 122         typesEntry.sprintf(TypesEntryFmt, i);
 123         if (!cf.hasKey(typesEntry))
 124             break;
 125
 126         QStringList typeNames = cf.readEntry(typesEntry, QStringList());
 127
 128         // now read them
 129         QString alias;
 130         for (QStringList::iterator it = typeNames.begin(); it != typeNames.end(); ++it)
 131         {
 132             KConfigGroup cf = confFile.group(*it);
 133             // check if this is an alias
 134             alias = cf.readEntry(AliasEntry);
 135             if (alias.isEmpty()) {
 136                 readType(cf, *it);
 137             } else {
 138                 // look up the alias type and insert it
 139                 TypeInfo* info = m_typeDict[alias];
 140                 if (info == 0) {
 141                     TRACE(*it + ": alias " + alias + " not found");
 142                 } else {
 143                     m_aliasDict.insert(alias, info);
 144                     TRACE(*it + ": alias " + alias);
 145                 }
 146             }
 147         }
 148     } // for all Types%d
 149 }
 150
 151 void TypeTable::readType(const KConfigGroup& cf, const QString& type)
 152 {
 153     // the display string
 154     QString expr = cf.readEntry(DisplayEntry);
 155
 156     TypeInfo* info = new TypeInfo(expr);
 157     if (info->m_numExprs == 0) {
 158         TRACE("bogus type " + type + ": no %% in Display: " + expr);
 159         delete info;
 160         return;
 161     }
 162
 163     info->m_templatePattern = cf.readEntry(TemplateEntry);
 164
 165     // Expr1, Expr2, etc...
 166     QString exprEntry;
 167     QString funcGuardEntry;
 168     for (int j = 0; j < info->m_numExprs; j++) {
 169         exprEntry.sprintf(ExprEntryFmt, j+1);
 170         expr = cf.readEntry(exprEntry);
 171         info->m_exprStrings[j] = expr;
 172
 173         funcGuardEntry.sprintf(FunctionGuardEntryFmt, j+1);
 174         expr = cf.readEntry(funcGuardEntry);
 175         info->m_guardStrings[j] = expr;
 176     }
 177
 178     // add the new type
 179     if (info->m_templatePattern.find('<') < 0)
 180         m_typeDict.insert(type, info);
 181     else
 182         m_templates[type] = info;
 183     TRACE(type + QString().sprintf(": %d exprs", info->m_numExprs));
 184 }
 185
 186 void TypeTable::copyTypes(Q3Dict<TypeInfo>& dict)
 187 {
 188     for (Q3DictIterator<TypeInfo> it = m_typeDict; it != 0; ++it) {
 189         dict.insert(it.currentKey(), it);
 190     }
 191     for (Q3DictIterator<TypeInfo> it = m_aliasDict; it != 0; ++it) {
 192         dict.insert(it.currentKey(), it);
 193     }
 194 }
 195
 196 bool TypeTable::isEnabledBuiltin(const QString& feature) const
 197 {
 198     return m_enabledBuiltins.find(feature) != m_enabledBuiltins.end();
 199 }
 200
 201 TypeInfo::TypeInfo(const QString& displayString)
 202 {
 203     // decompose the input into the parts
 204     int i = 0;
 205     int startIdx = 0;
 206     int idx;
 207     while (i < typeInfoMaxExpr &&
 208            (idx = displayString.find('%', startIdx)) >= 0)
 209     {
 210         m_displayString[i] = displayString.mid(startIdx, idx-startIdx);
 211         startIdx = idx+1;
 212         i++;
 213     }
 214     m_numExprs = i;
 215     /*
 216      * Remaining string; note that there's one more display string than
 217      * sub-expressions.
 218      */
 219     m_displayString[i] = displayString.right(displayString.length()-startIdx);
 220 }
 221
 222 TypeInfo::~TypeInfo()
 223 {
 224 }
 225
 226
 227 ProgramTypeTable::ProgramTypeTable() :
 228         m_parseQt2QStrings(false),
 229         m_QCharIsShort(false),
 230         m_printQStringDataCmd(0)
 231 {
 232     m_types.setAutoDelete(false);       /* paranoia */
 233     m_aliasDict.setAutoDelete(false);   /* paranoia */
 234 }
 235
 236 ProgramTypeTable::~ProgramTypeTable()
 237 {
 238 }
 239
 240 void ProgramTypeTable::loadTypeTable(TypeTable* table)
 241 {
 242     table->copyTypes(m_types);
 243
 244     // add templates
 245     const TypeTable::TypeMap& t = table->templates();
 246     std::transform(t.begin(), t.end(),
 247                 std::inserter(m_templates, m_templates.begin()),
 248                 std::ptr_fun(template2Info));
 249
 250     // check whether to enable builtin QString support
 251     if (!m_parseQt2QStrings) {
 252         m_parseQt2QStrings = table->isEnabledBuiltin("QString::Data");
 253     }
 254     if (!m_QCharIsShort) {
 255         m_QCharIsShort = table->isEnabledBuiltin("QCharIsShort");
 256     }
 257     if (!m_printQStringDataCmd && *table->printQStringDataCmd()) {
 258         m_printQStringDataCmd = table->printQStringDataCmd();
 259     }
 260 }
 261
 262 ProgramTypeTable::TemplateMap::value_type
 263         ProgramTypeTable::template2Info(const TypeTable::TypeMap::value_type& tt)
 264 {
 265     QStringList args = splitTemplateArgs(tt.second->m_templatePattern);
 266
 267     TemplateMap::value_type result(args.front(), TemplateInfo());
 268     result.second.type = tt.second;
 269     args.pop_front();
 270     result.second.templateArgs = args;
 271     return result;
 272 }
 273
 274 /**
 275  * Splits the name \a t into the template name and its arguments.
 276  * The first entry of the returned list is the template name, the remaining
 277  * entries are the arguments.
 278  */
 279 QStringList ProgramTypeTable::splitTemplateArgs(const QString& t)
 280 {
 281     QStringList result;
 282     result.push_back(t);
 283
 284     int i = t.find('<');
 285     if (i < 0)
 286         return result;
 287
 288     // split off the template name
 289     result.front().truncate(i);
 290
 291     i++;        // skip '<'
 292     // look for the next comma or the closing '>', skipping nested '<>'
 293     int nest = 0;
 294     int start = i;
 295     for (; unsigned(i) < t.length() && nest >= 0; i++)
 296     {
 297         if (t[i] == '<')
 298             nest++;
 299         else if (t[i] == '>')
 300             nest--;
 301         else if (nest == 0 && t[i] == ',') {
 302             // found end of argument
 303             QString arg = t.mid(start, i-start);
 304             result.push_back(arg);
 305             start = i+1;        // skip ','
 306         }
 307     }
 308     // accept the template only if the closing '>' is the last character
 309     if (nest < 0 && unsigned(i) == t.length()) {
 310         QString arg = t.mid(start, i-start-1);
 311         result.push_back(arg);
 312     } else {
 313         result.clear();
 314         result.push_back(t);
 315     }
 316     return result;
 317 }
 318
 319 TypeInfo* ProgramTypeTable::lookup(QString type)
 320 {
 321     /*
 322      * Registered aliases contain the complete template parameter list.
 323      * Check for an alias first so that this case is out of the way.
 324      */
 325     if (TypeInfo* result = m_aliasDict[type])
 326         return result;
 327
 328     /*
 329      * Check for a normal type. Even if type is a template instance,
 330      * it could have been registered as a normal type instead of a pattern.
 331      */
 332     if (TypeInfo* result = m_types[type])
 333         return result;
 334
 335     /*
 336      * The hard part: Look up a template.
 337      */
 338     QStringList parts = splitTemplateArgs(type);
 339     if (parts.size() == 1)
 340         return 0;       // not a template
 341
 342     // We can have several patterns for the same template name.
 343     std::pair<TemplateMap::const_iterator, TemplateMap::const_iterator> range =
 344         m_templates.equal_range(parts.front());
 345     // We pick the one that has the wildcards in the later parameters.
 346     unsigned minPenalty = ~0U;
 347     TypeInfo* result = 0;
 348     parts.pop_front();
 349
 350     for (TemplateMap::const_iterator i = range.first; i != range.second; ++i)
 351     {
 352         const QStringList& pat = i->second.templateArgs;
 353         if (parts.size() < pat.size())
 354             continue;   // too few arguments
 355
 356         // a "*" in the last position of the pattern matches all arguments
 357         // at the end of the template's arguments
 358         if (parts.size() > pat.size() && pat.back() != "*")
 359             continue;   // too many arguments and no wildcard
 360
 361         QStringList::const_iterator t = parts.begin();
 362         QStringList::const_iterator p = pat.begin();
 363         unsigned accumPenalty = 0;
 364         bool equal = true;
 365         unsigned penalty = ~(~0U>>1);   // 1 in the leading bit
 366         while (equal && p != pat.end())
 367         {
 368             if (*p == "*")
 369                 accumPenalty |= penalty;        // penalize wildcards
 370             else
 371                 equal = *p == *t;
 372             ++p, ++t, penalty >>= 1;
 373         }
 374         if (equal)
 375         {
 376             if (accumPenalty == 0)
 377                 return i->second.type;
 378             if (accumPenalty < minPenalty) {
 379                 result = i->second.type;
 380                 minPenalty = accumPenalty;
 381             }
 382         }
 383     }
 384     return result;
 385 }
 386
 387 void ProgramTypeTable::registerAlias(const QString& name, TypeInfo* type)
 388 {
 389     ASSERT(lookup(name) == 0 || lookup(name) == type);
 390     m_aliasDict.insert(name, type);
 391 }
 392
 393 void ProgramTypeTable::loadLibTypes(const QStringList& libs)
 394 {
 395     for (QStringList::const_iterator it = libs.begin(); it != libs.end(); ++it)
 396     {
 397         // look up the library
 398         for (std::list<TypeTable>::iterator t = typeTables.begin(); t != typeTables.end(); ++t)
 399         {
 400             if (t->matchFileName(*it))
 401             {
 402                 TRACE("adding types for " + *it);
 403                 loadTypeTable(&*t);
 404             }
 405         }
 406     }
 407 }