tools/qdoc3/qscodeparser.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the tools applications of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** No Commercial Usage
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 /*
  43   qscodeparser.cpp
  44 */
  45
  46 #include <qfile.h>
  47 #include <qregexp.h>
  48
  49 #include "config.h"
  50 #include "qscodeparser.h"
  51 #include "text.h"
  52 #include "tokenizer.h"
  53 #include "tree.h"
  54
  55 QT_BEGIN_NAMESPACE
  56
  57 #define CONFIG_QUICK                    "quick"
  58 #define CONFIG_REPLACES                 "replaces"
  59
  60 #define COMMAND_BRIEF                   Doc::alias( "brief")
  61 #define COMMAND_CODE                    Doc::alias( "code")
  62 #define COMMAND_ENDCODE                 Doc::alias( "endcode")
  63 #define COMMAND_ENDQUICKCODE            Doc::alias( "endquickcode")
  64 #define COMMAND_FILE                    Doc::alias( "file")
  65 #define COMMAND_GROUP                   Doc::alias( "group")
  66 #define COMMAND_MODULE                  Doc::alias( "module")
  67 #define COMMAND_PAGE                    Doc::alias( "page")
  68 #define COMMAND_QUICKCLASS              Doc::alias( "quickclass")
  69 #define COMMAND_QUICKCODE               Doc::alias( "quickcode")
  70 #define COMMAND_QUICKENUM               Doc::alias( "quickenum")
  71 #define COMMAND_QUICKFN                 Doc::alias( "quickfn")
  72 #define COMMAND_QUICKIFY                Doc::alias( "quickify")
  73 #define COMMAND_QUICKPROPERTY           Doc::alias( "quickproperty")
  74 #define COMMAND_PROTECTED               Doc::alias( "protected")
  75 #define COMMAND_REPLACE                 Doc::alias( "replace")
  76
  77 static QString balancedParens = "(?:[^()]+|\\([^()]*\\))*";
  78
  79 QsCodeParser::QsCodeParser(Tree *cppTree)
  80     : cppTre(cppTree), qsTre(0), replaceRegExp("/(.+)/([^/]*)/")
  81 {
  82 }
  83
  84 QsCodeParser::~QsCodeParser()
  85 {
  86 }
  87
  88 void QsCodeParser::initializeParser(const Config& config)
  89 {
  90     CppCodeParser::initializeParser(config);
  91
  92     nodeTypeMap.insert(COMMAND_QUICKCLASS, Node::Class);
  93     nodeTypeMap.insert(COMMAND_QUICKENUM, Node::Enum);
  94     nodeTypeMap.insert(COMMAND_QUICKPROPERTY, Node::Property);
  95     nodeTypeMap.insert(COMMAND_QUICKFN, Node::Function);
  96
  97     QString quickDotReplaces = CONFIG_QUICK + Config::dot + CONFIG_REPLACES;
  98     QStringList replaces = config.getStringList(quickDotReplaces);
  99     QStringList::ConstIterator r = replaces.begin();
 100     while (r != replaces.end()) {
 101         if (replaceRegExp.exactMatch(*r)) {
 102             QRegExp before(replaceRegExp.cap(1));
 103             before.setMinimal(true);
 104             QString after = replaceRegExp.cap(2);
 105
 106             if (before.isValid()) {
 107                 replaceBefores << before;
 108                 replaceAfters << after;
 109             }
 110             else {
 111                 config.lastLocation().warning(
 112                         tr("Invalid regular expression '%1'")
 113                         .arg(before.pattern()));
 114             }
 115         }
 116         else {
 117             config.lastLocation().warning(tr("Bad syntax in '%1'")
 118                                            .arg(quickDotReplaces));
 119         }
 120         ++r;
 121     }
 122 }
 123
 124 void QsCodeParser::terminateParser()
 125 {
 126     nodeTypeMap.clear();
 127     classesWithNoQuickDoc.clear();
 128     replaceBefores.clear();
 129     replaceAfters.clear();
 130     CppCodeParser::terminateParser();
 131 }
 132
 133 QString QsCodeParser::language()
 134 {
 135     return "Qt Script";
 136 }
 137
 138 QString QsCodeParser::headerFileNameFilter()
 139 {
 140     return "*";
 141 }
 142
 143 QString QsCodeParser::sourceFileNameFilter()
 144 {
 145     return "*.qs *.qsd";
 146 }
 147
 148 void QsCodeParser::parseHeaderFile(const Location& location,
 149                                    const QString& filePath,
 150                                    Tree *tree)
 151 {
 152     qsTre = tree;
 153
 154     FILE *in = fopen(QFile::encodeName(filePath), "r");
 155     if (in == 0) {
 156         location.error(tr("Cannot open Qt Script class list '%1'")
 157                         .arg(filePath));
 158         return;
 159     }
 160
 161     Location fileLocation(filePath);
 162     Tokenizer fileTokenizer(fileLocation, in);
 163     int tok = fileTokenizer.getToken();
 164     while (tok != Tok_Eoi) {
 165         if (tok == Tok_Ident) {
 166             ClassNode *quickClass = new ClassNode(qsTre->root(),
 167                                                    fileTokenizer.lexeme());
 168             quickClass->setLocation(fileTokenizer.location());
 169         }
 170         else {
 171             fileTokenizer.location().error(tr("Unexpected token '%1' in Qt"
 172                                                " Script class list")
 173                                             .arg(fileTokenizer.lexeme()));
 174             break;
 175         }
 176         tok = fileTokenizer.getToken();
 177     }
 178     fclose(in);
 179 }
 180
 181 void QsCodeParser::parseSourceFile(const Location& location,
 182                                    const QString& filePath,
 183                                    Tree *tree)
 184 {
 185     qsTre = tree;
 186     CppCodeParser::parseSourceFile(location, filePath, tree);
 187 }
 188
 189 void QsCodeParser::doneParsingHeaderFiles(Tree *tree)
 190 {
 191     NodeList::ConstIterator c = tree->root()->childNodes().begin();
 192     while (c != tree->root()->childNodes().end()) {
 193         if ((*c)->type() == Node::Class)
 194             quickifyClass((ClassNode *) *c);
 195         ++c;
 196     }
 197     cppTre->root()->deleteChildren(); // save memory
 198     tree->resolveInheritance();
 199     tree->resolveProperties();
 200 }
 201
 202 void QsCodeParser::doneParsingSourceFiles(Tree *tree)
 203 {
 204     tree->root()->normalizeOverloads();
 205
 206     NodeList::ConstIterator c = tree->root()->childNodes().begin();
 207     while (c != tree->root()->childNodes().end()) {
 208         if ((*c)->type() == Node::Class) {
 209             QMap<QString, Node *>::ConstIterator cwnqd =
 210                     classesWithNoQuickDoc.find((*c)->name());
 211             if (cwnqd != classesWithNoQuickDoc.end()) {
 212                 (*cwnqd)->location().warning(tr("No '\\%1' documentation for"
 213                                                  " class '%2'")
 214                                               .arg(COMMAND_QUICKCLASS)
 215                                               .arg(cwnqd.key()));
 216                 (*cwnqd)->setDoc(Doc(), true);
 217             }
 218         }
 219         ++c;
 220     }
 221
 222     // ### check which enum types are used
 223 }
 224
 225 FunctionNode *QsCodeParser::findFunctionNode(const QString& synopsis,
 226                                               Tree *tree)
 227 {
 228     QStringList parentPath;
 229     FunctionNode *clone;
 230     FunctionNode *func = 0;
 231
 232     if (makeFunctionNode(synopsis, &parentPath, &clone)) {
 233         func = tree->findFunctionNode(parentPath, clone);
 234         delete clone;
 235     }
 236     return func;
 237 }
 238
 239 QSet<QString> QsCodeParser::topicCommands()
 240 {
 241     return QSet<QString>() << COMMAND_FILE << COMMAND_GROUP << COMMAND_MODULE
 242                            << COMMAND_PAGE << COMMAND_QUICKCLASS
 243                            << COMMAND_QUICKENUM << COMMAND_QUICKFN
 244                            << COMMAND_QUICKPROPERTY;
 245 }
 246
 247 Node *QsCodeParser::processTopicCommand(const Doc& doc,
 248                                         const QString& command,
 249                                         const QString& arg)
 250 {
 251     if (command == COMMAND_QUICKFN) {
 252         QStringList parentPath;
 253         FunctionNode *quickFunc = 0;
 254         FunctionNode *clone;
 255
 256         if (makeFunctionNode(arg, &parentPath, &clone)) {
 257             FunctionNode *kernelFunc = findKernelFunction(parentPath,
 258                                                            clone->name());
 259             if (kernelFunc != 0)
 260                 kernelFunc->setAccess(Node::Private);
 261
 262             quickFunc = qsTre->findFunctionNode(parentPath, clone);
 263             if (quickFunc == 0 && kernelFunc != 0) {
 264                 quickFunc = new FunctionNode(kernelFunc->parent(),
 265                                               kernelFunc->name());
 266                 quickFunc->setLocation(kernelFunc->location());
 267                 quickFunc->setReturnType(clone->returnType());
 268                 quickFunc->setParameters(clone->parameters());
 269             }
 270
 271             if (quickFunc == 0) {
 272                 doc.location().warning(tr("Cannot find '%1' specified with '\\%2'")
 273                                         .arg(arg).arg(command));
 274             }
 275             else {
 276                 quickFunc->setAccess(Node::Public);
 277                 QStringList qtParams = quickFunc->parameterNames();
 278                 quickFunc->borrowParameterNames(clone);
 279                 QStringList quickParams = quickFunc->parameterNames();
 280                 setQuickDoc(quickFunc, doc, qtParams, quickParams);
 281             }
 282             delete clone;
 283         }
 284         else {
 285             doc.location().warning(tr("Cannot find '%1' specified with '\\%2'")
 286                                     .arg(arg).arg(command));
 287         }
 288         return 0;
 289     }
 290     else if (nodeTypeMap.contains(command)) {
 291         QStringList subArgs = arg.split(" ");
 292         QString dataType;
 293
 294         if (subArgs.count() == 3 && subArgs[1] == ":") {
 295             dataType = subArgs[2];
 296         }
 297         else if (subArgs.count() != 1) {
 298             doc.location().warning(tr("Invalid syntax in '\\%1'")
 299                                     .arg(command));
 300         }
 301
 302         QStringList path = subArgs[0].split(".");
 303         Node *quickNode = qsTre->findNode(path, nodeTypeMap[command]);
 304         if (quickNode == 0) {
 305             doc.location().warning(tr("Cannot find '%1' specified with '\\%2'")
 306                                     .arg(arg).arg(command));
 307         }
 308         else {
 309             setQuickDoc(quickNode, doc);
 310             if (quickNode->type() == Node::Class) {
 311                 classesWithNoQuickDoc.remove(quickNode->name());
 312                 if (doc.briefText().isEmpty())
 313                     doc.location().warning(tr("Missing '\\%1' for class '%2'")
 314                                             .arg(COMMAND_BRIEF)
 315                                             .arg(quickNode->name()));
 316             }
 317             else if (quickNode->type() == Node::Property) {
 318                 PropertyNode *quickProperty = (PropertyNode *) quickNode;
 319                 if (quickProperty->dataType() == "Object") {
 320                     if (dataType.isEmpty()) {
 321                         doc.location().warning(tr("Missing data type in '\\%1'"
 322                                                    " (assuming 'Object')")
 323                                                 .arg(command));
 324                     }
 325                     else {
 326                         quickProperty->setDataType(dataType);
 327                     }
 328                 }
 329                 else if (dataType != quickProperty->dataType()) {
 330                     doc.location().warning(tr("Ignored contradictory data type"
 331                                                " in '\\%1'")
 332                                             .arg(command));
 333                 }
 334             }
 335         }
 336         return 0;
 337     }
 338     else {
 339         return CppCodeParser::processTopicCommand(doc, command, arg);
 340     }
 341 }
 342
 343 QSet<QString> QsCodeParser::otherMetaCommands()
 344 {
 345     return commonMetaCommands() << COMMAND_ENDQUICKCODE << COMMAND_QUICKCODE
 346                                 << COMMAND_QUICKIFY << COMMAND_REPLACE;
 347 }
 348
 349 void QsCodeParser::processOtherMetaCommand(const Doc& doc,
 350                                            const QString& command,
 351                                            const QString& arg,
 352                                            Node *node)
 353 {
 354     if (command == COMMAND_PROTECTED) {
 355         doc.location().warning(tr("Cannot use '\\%1' in %2")
 356                                 .arg(COMMAND_PROTECTED).arg(language()));
 357     }
 358     else {
 359         CppCodeParser::processOtherMetaCommand(doc,command,arg,node);
 360     }
 361 }
 362
 363 ClassNode *QsCodeParser::tryClass(const QString& className)
 364 {
 365     return (ClassNode*) cppTre->findNode(QStringList(className),Node::Class);
 366 }
 367
 368 FunctionNode *QsCodeParser::findKernelFunction(const QStringList& parentPath,
 369                                                const QString& name)
 370 {
 371     FunctionNode clone(0, name);
 372     clone.setReturnType("Object");
 373     clone.addParameter(Parameter("..."));
 374     return qsTre->findFunctionNode(parentPath, &clone);
 375 }
 376
 377 void QsCodeParser::extractRegExp(const QRegExp& regExp,
 378                                  QString& source,
 379                                  const Doc& doc)
 380 {
 381     QRegExp blankLineRegExp(
 382             "[ \t]*(?:\n(?:[ \t]*\n)+[ \t]*|[ \n\t]*\\\\code|"
 383             "\\\\endcode[ \n\t]*)");
 384     QStringList paras = source.trimmed().split(blankLineRegExp);
 385     paras = paras.filter(regExp);
 386     if (paras.count() == 0) {
 387         doc.location().warning(tr("Cannot find regular expression '%1'")
 388                                 .arg(regExp.pattern()));
 389     }
 390     else if (paras.count() > 1) {
 391         doc.location().warning(tr("Regular rexpression '%1' matches multiple"
 392                                    "times").arg(regExp.pattern()));
 393     }
 394     else {
 395         source = paras.first() + "\n\n";
 396     }
 397 }
 398
 399 void QsCodeParser::extractTarget(const QString& target,
 400                                  QString& source,
 401                                  const Doc& doc)
 402 {
 403     QRegExp targetRegExp(
 404             "(\\\\target\\s+(\\S+)[^\n]*\n"
 405             "(?:(?!\\s*\\\\code)[^\n]+\n|\\s*\\\\code.*\\\\endcode\\s*\n)*)"
 406             "(?:\\s*\n|[^\n]*$)");
 407     targetRegExp.setMinimal(true);
 408
 409     int pos = 0;
 410     while ((pos = source.indexOf(targetRegExp, pos)) != -1) {
 411         if (targetRegExp.cap(2) == target) {
 412             source = targetRegExp.cap(1) + "\n\n";
 413             return;
 414         }
 415         pos += targetRegExp.matchedLength();
 416     }
 417     doc.location().warning(tr("Cannot find target '%1'").arg(target));
 418 }
 419
 420 void QsCodeParser::renameParameters(QString& source,
 421                                     const Doc& /* doc */,
 422                                     const QStringList& qtParams,
 423                                     const QStringList& quickParams)
 424 {
 425     QRegExp paramRegExp("(\\\\a\\s*\\{?\\s*)([A-Za-z0-9_]+)");
 426
 427     int pos = 0;
 428     while ((pos = paramRegExp.indexIn(source, pos)) != -1) {
 429         pos += paramRegExp.cap(1).length();
 430         QString before = paramRegExp.cap(2);
 431         int index = qtParams.indexOf(before);
 432         if (index != -1) {
 433             QString after = quickParams[index];
 434             source.replace(pos, before.size(), after);
 435         }
 436     }
 437 }
 438
 439 void QsCodeParser::applyReplacementList(QString& source, const Doc& doc)
 440 {
 441     QStringList args = doc.metaCommandArgs(COMMAND_REPLACE);
 442     QStringList::ConstIterator a = args.begin();
 443     while (a != args.end()) {
 444         if (replaceRegExp.exactMatch(*a)) {
 445             QRegExp before(replaceRegExp.cap(1));
 446             before.setMinimal(true);
 447             QString after = replaceRegExp.cap(2);
 448
 449             if (before.isValid()) {
 450                 int oldLen = source.size();
 451                 source.replace(before, after);
 452
 453                 // this condition is sufficient but not necessary
 454                 if (oldLen == source.size() && !source.contains(after))
 455                     doc.location().warning(
 456                             tr("Regular expression '%1' did not match anything")
 457                             .arg(before.pattern()));
 458             }
 459             else {
 460                 doc.location().warning(
 461                         tr("Invalid regular expression '%1'")
 462                         .arg(before.pattern()));
 463             }
 464         }
 465         else {
 466             doc.location().warning(tr("Bad syntax in '\\%1'")
 467                                     .arg(COMMAND_REPLACE));
 468         }
 469         ++a;
 470     }
 471
 472     QRegExp codeRegExp("\\\\" + COMMAND_CODE + "(.*)\\\\" + COMMAND_ENDCODE);
 473     codeRegExp.setMinimal(true);
 474
 475     QRegExp quickcodeRegExp(
 476             "\\\\" + COMMAND_QUICKCODE + "(.*)\\\\" + COMMAND_ENDQUICKCODE);
 477     quickcodeRegExp.setMinimal(true);
 478
 479     int quickcodePos = doc.source().indexOf(quickcodeRegExp);
 480     if (quickcodePos != -1) {
 481         int codePos = source.indexOf(codeRegExp);
 482         if (codePos == -1) {
 483             doc.location().warning(
 484                     tr("Cannot find any '\\%1' snippet corresponding to '\\%2'")
 485                     .arg(COMMAND_CODE).arg(COMMAND_QUICKCODE));
 486         }
 487         else {
 488             source.replace(codeRegExp.pos(1), codeRegExp.cap(1).length(),
 489                             quickcodeRegExp.cap(1));
 490             codePos = codeRegExp.pos(1) + quickcodeRegExp.cap(1).length();
 491
 492             if (doc.source().indexOf(quickcodeRegExp, quickcodePos + 1) != -1) {
 493                 doc.location().warning(
 494                         tr("Cannot use '\\%1' twice in a row")
 495                         .arg(COMMAND_QUICKCODE));
 496             }
 497             else if (source.indexOf(codeRegExp, codePos + 1) != -1) {
 498                 doc.location().warning(tr("Ambiguous '\\%1'")
 499                                         .arg(COMMAND_QUICKCODE));
 500             }
 501         }
 502     }
 503 }
 504
 505 void QsCodeParser::quickifyClass(ClassNode *quickClass)
 506 {
 507     QString qtClassName = quickClass->name();
 508     QString bare = quickClass->name();
 509     if (bare != "Qt" && bare != "Object") {
 510         if (bare.startsWith("Q")) {
 511             bare = bare.mid(1);
 512         }
 513         else {
 514             qtClassName.prepend("Q");
 515             classesWithNoQ.insert(bare);
 516         }
 517     }
 518
 519     ClassNode *qtClass = 0;
 520     ClassNode *wrapperClass = 0;
 521
 522     if ((wrapperClass = tryClass("Quick" + bare)) != 0 ||
 523          (wrapperClass = tryClass("QS" + bare + "Class")) != 0) {
 524         qtClass = tryClass(qtClassName);
 525         if (qtClass == 0) {
 526             qtClass = wrapperClass;
 527             wrapperClass = 0;
 528         }
 529     }
 530     else if ((wrapperClass = tryClass("Quick" + bare + "Ptr")) != 0) {
 531         QRegExp ptrToQtType("(Q[A-Za-z0-9_]+)\\s*\\*");
 532         FunctionNode *ctor =
 533                 wrapperClass->findFunctionNode(wrapperClass->name());
 534         if (ctor != 0 && !ctor->parameters().isEmpty() &&
 535              ptrToQtType.exactMatch(ctor->parameters().first().leftType()))
 536             qtClassName = ptrToQtType.cap(1);
 537         qtClass = tryClass(qtClassName);
 538     }
 539     else {
 540         wrapperClass = tryClass("Q" + bare + "Ptr");
 541         if (wrapperClass == 0)
 542             wrapperClass = tryClass("Quick" + bare + "Interface");
 543         qtClass = tryClass(qtClassName);
 544     }
 545
 546     if (qtClass == 0) {
 547         if (wrapperClass == 0) {
 548             quickClass->location().warning(tr("Cannot find Qt class '%1'")
 549                                             .arg(qtClassName));
 550         }
 551         else {
 552             quickClass->location().warning(tr("Cannot find Qt class '%1'"
 553                                                " wrapped by '%2'")
 554                                             .arg(qtClassName)
 555                                             .arg(wrapperClass->name()));
 556         }
 557         return;
 558     }
 559
 560     QList<RelatedClass>::ConstIterator r = qtClass->baseClasses().begin();
 561     while (r != qtClass->baseClasses().end()) {
 562         ClassNode *quickBaseClass = cpp2qs.findClassNode(qsTre,
 563                                                          (*r).node->name());
 564         if (quickBaseClass)
 565             quickClass->addBaseClass((*r).access, quickBaseClass);
 566         ++r;
 567     }
 568     if (quickClass->baseClasses().isEmpty() && quickClass->name() != "Object")
 569         quickClass->addBaseClass(Node::Public,
 570                                  cpp2qs.findClassNode(qsTre,"Object"));
 571
 572     QSet<QString> funcBlackList;
 573     QSet<QString> propertyBlackList;
 574
 575     NodeList children;
 576     if (wrapperClass != 0) {
 577         children = wrapperClass->childNodes();
 578
 579         funcBlackList.insert(wrapperClass->name());
 580         funcBlackList.insert("~" + wrapperClass->name());
 581     }
 582     children += qtClass->childNodes();
 583
 584     for (int pass = 0; pass < 2; pass++) {
 585         NodeList::ConstIterator c = children.begin();
 586         while (c != children.end()) {
 587             if ((*c)->access() != Node::Private &&
 588                  (*c)->status() == Node::Commendable) {
 589                 if (pass == 0) {
 590                     if ((*c)->type() == Node::Enum) {
 591                         EnumNode *enume = (EnumNode *) *c;
 592                         quickifyEnum(quickClass, enume);
 593                     }
 594                     else if ((*c)->type() == Node::Property) {
 595                         if (!propertyBlackList.contains((*c)->name())) {
 596                             PropertyNode *property = (PropertyNode *) *c;
 597                             quickifyProperty(quickClass, qtClass, property);
 598                             if (!property->getters().isEmpty())
 599                                 funcBlackList.insert(property->getters().first()->name());
 600                             if (!property->setters().isEmpty())
 601                                 funcBlackList.insert(property->setters().first()->name());
 602                             if (!property->resetters().isEmpty())
 603                                 funcBlackList.insert(property->resetters().first()->name());
 604                             propertyBlackList.insert(property->name());
 605                         }
 606                     }
 607                 }
 608                 else if ((*c)->type() == Node::Function)  {
 609                     FunctionNode *func = (FunctionNode *) *c;
 610                     quickifyFunction(quickClass, qtClass, func,
 611                                       funcBlackList.contains((*c)->name()) &&
 612                                       func->parameters().count() < 2);
 613                 }
 614             }
 615             ++c;
 616         }
 617     }
 618     setQtDoc(quickClass, qtClass->doc());
 619     classesWithNoQuickDoc.insert(quickClass->name(), quickClass);
 620 }
 621
 622 void QsCodeParser::quickifyEnum(ClassNode *quickClass, EnumNode *enume)
 623 {
 624     EnumNode *quickEnum = new EnumNode(quickClass, enume->name());
 625     quickEnum->setLocation(enume->location());
 626 #if 0 // ### not yet
 627     quickEnum->setAccess(Node::Protected);
 628 #endif
 629
 630     QList<EnumItem>::ConstIterator it = enume->items().begin();
 631     while (it != enume->items().end()) {
 632         QString name = (*it).name();
 633         QString value = (*it).value();
 634         quickEnum->addItem(EnumItem(name, value));
 635         ++it;
 636     }
 637     setQtDoc(quickEnum, enume->doc());
 638 }
 639
 640 void QsCodeParser::quickifyFunction(ClassNode *quickClass, ClassNode *qtClass,
 641                                      FunctionNode *func, bool onBlackList)
 642 {
 643     if (func->metaness() == FunctionNode::Dtor)
 644         return;
 645
 646     FunctionNode *kernelFunc = findKernelFunction(
 647             QStringList() << quickClass->name(), func->name());
 648
 649     QString quickName = func->name();
 650     if (func->metaness() == FunctionNode::Ctor)
 651         quickName = quickClass->name();
 652     FunctionNode *quickFunc = new FunctionNode(quickClass, quickName);
 653     quickFunc->setLocation(func->location());
 654
 655     if (onBlackList) {
 656         quickFunc->setAccess(Node::Protected);
 657     }
 658     else {
 659         if (kernelFunc != 0 && func->numOverloads() == 1 &&
 660              (func->parameters().count() == 0 ||
 661               func->parameters().last().defaultValue().isEmpty())) {
 662             kernelFunc->setAccess(Node::Private);
 663         }
 664         else {
 665             if (func->metaness() == FunctionNode::Plain)
 666                 quickFunc->setAccess(Node::Protected);
 667         }
 668     }
 669
 670     quickFunc->setReturnType(cpp2qs.convertedDataType(qsTre,
 671                                                        func->returnType()));
 672     if (func->metaness() != FunctionNode::Slot)
 673         quickFunc->setMetaness(func->metaness());
 674     quickFunc->setVirtualness(FunctionNode::ImpureVirtual);
 675     quickFunc->setOverload(func->isOverload());
 676
 677     QList<Parameter>::ConstIterator q = func->parameters().begin();
 678     while (q != func->parameters().end()) {
 679         QString dataType = cpp2qs.convertedDataType(qsTre, (*q).leftType(),
 680                                                      (*q).rightType());
 681         if (dataType.isEmpty()) {
 682             dataType = "UNKNOWN";
 683             quickFunc->setAccess(Node::Private);
 684         }
 685         Parameter param(dataType, "", (*q).name(),
 686                          (*q).defaultValue().isEmpty() ? "" : "undefined");
 687         quickFunc->addParameter(param);
 688         ++q;
 689     }
 690
 691     if (func->doc().isEmpty()) {
 692         if (func->parent() != (InnerNode *) qtClass) {
 693             func = qtClass->findFunctionNode(func);
 694             if (func != 0)
 695                 setQtDoc(quickFunc, func->doc());
 696         }
 697     }
 698     else {
 699         setQtDoc(quickFunc, func->doc());
 700     }
 701 }
 702
 703 void QsCodeParser::quickifyProperty(ClassNode *quickClass,
 704                                     ClassNode * /* qtClass */,
 705                                     PropertyNode *property)
 706 {
 707     PropertyNode *quickProperty = new PropertyNode(quickClass,
 708                                                    property->name());
 709     quickProperty->setLocation(property->location());
 710     quickProperty->setDataType(cpp2qs.convertedDataType(qsTre,
 711                                                         property->dataType()));
 712 #if 0
 713     quickProperty->setGetter(property->getter());
 714     quickProperty->setSetter(property->setter());
 715     quickProperty->setResetter(property->resetter());
 716 #endif
 717     quickProperty->setStored(property->isStored());
 718     quickProperty->setDesignable(property->isDesignable());
 719
 720     setQtDoc(quickProperty, property->doc());
 721 }
 722
 723 QString QsCodeParser::quickifiedDoc(const QString& source)
 724 {
 725     QString result;
 726     int i = 0;
 727
 728     while (i < (int) source.length()) {
 729         if (leftWordBoundary(source, i)) {
 730             if (source[i] == 'Q') {
 731                 if (source[i + 1] == 'C' && source.mid(i, 8) == "QCString") {
 732                     i += 2;
 733                 }
 734                 else {
 735                     int end = i + 1;
 736                     while (isWord(source[end]))
 737                         ++end;
 738                     if (!classesWithNoQ.contains(
 739                                   source.mid(i + 1, end - (i + 1))))
 740                         result += "Q";
 741                     i++;
 742                 }
 743             }
 744             else if (source[i] == 'T' && source.mid(i, 4) == "TRUE" &&
 745                         rightWordBoundary(source, i + 4)) {
 746                 result += "\\c{true}";
 747                 i += 4;
 748             }
 749             else if (source[i] == 'F' && source.mid(i, 5) == "FALSE" &&
 750                         rightWordBoundary(source, i + 5)) {
 751                 result += "\\c{false}";
 752                 i += 5;
 753             }
 754             else if (source[i] == 'c' && source.mid(i, 6) == "const ") {
 755                 i += 6;
 756             }
 757             else {
 758                 result += source[i++];
 759             }
 760         }
 761         else if ((source[i] == ':' && source[i + 1] == ':') ||
 762                     (source[i] == '-' && source[i + 1] == '>')) {
 763             result += '.';
 764             i += 2;
 765         }
 766         else if (source[i] == '\\') {
 767             // ### make independent of the command name
 768             if (source.mid(i, 5) == "\\code") {
 769                 do {
 770                     result += source[i++];
 771                 } while (source[i - 1] != '\n');
 772
 773                 int begin = i;
 774                 int end = source.indexOf("\\endcode", i);
 775                 if (end != -1) {
 776                     QString code = source.mid(begin, end - begin);
 777                     result += cpp2qs.convertedCode(qsTre, code,
 778                                                     classesWithNoQ);
 779                     i = end;
 780                 }
 781             }
 782             else {
 783                 result += source[i++];
 784             }
 785         }
 786         else {
 787             result += source[i++];
 788         }
 789     }
 790
 791     QList<QRegExp>::ConstIterator b = replaceBefores.begin();
 792     QStringList::ConstIterator a = replaceAfters.begin();
 793     while (a != replaceAfters.end()) {
 794         result.replace(*b, *a);
 795         ++b;
 796         ++a;
 797     }
 798     return result;
 799 }
 800
 801 void QsCodeParser::setQtDoc(Node *quickNode, const Doc& doc)
 802 {
 803     if (!doc.isEmpty()) {
 804         Doc quickDoc(doc.location(), doc.location(),
 805                      quickifiedDoc(doc.source()),
 806                      CppCodeParser::topicCommands() +
 807                      CppCodeParser::otherMetaCommands());
 808         quickNode->setDoc(quickDoc, true);
 809     }
 810 }
 811
 812 void QsCodeParser::setQuickDoc(Node *quickNode,
 813                                const Doc& doc,
 814                                const QStringList& qtParams,
 815                                const QStringList& quickParams)
 816 {
 817     QRegExp quickifyCommand("\\\\" + COMMAND_QUICKIFY + "([^\n]*)(?:\n|$)");
 818
 819     if (quickNode->type() == Node::Function) {
 820         FunctionNode *quickFunc = (FunctionNode *) quickNode;
 821         quickFunc->setOverload(false);
 822     }
 823
 824     if (doc.metaCommandsUsed().contains(COMMAND_QUICKIFY)) {
 825         QString source = doc.source();
 826         int pos = source.indexOf(quickifyCommand);
 827         if (pos != -1) {
 828             QString quickifiedSource = quickNode->doc().source();
 829             if (!qtParams.isEmpty() && qtParams != quickParams)
 830                 renameParameters(quickifiedSource, doc, qtParams,
 831                                   quickParams);
 832             applyReplacementList(quickifiedSource, doc);
 833
 834             do {
 835                 QString extract = quickifiedSource;
 836                 QString arg = quickifyCommand.cap(1).simplified();
 837                 if (!arg.isEmpty()) {
 838                     if (arg.startsWith("/") && arg.endsWith("/") &&
 839                          arg.length() > 2) {
 840                         QString pattern = arg.mid(1, arg.length() - 2);
 841                         extractRegExp(QRegExp(pattern), extract, doc);
 842                     }
 843                     else {
 844                         extractTarget(arg, extract, doc);
 845                     }
 846                 }
 847                 source.replace(pos, quickifyCommand.matchedLength(), extract);
 848                 pos += extract.length();
 849             } while ((pos = source.indexOf(quickifyCommand, pos)) != -1);
 850
 851             QRegExp quickcodeRegExp(
 852                     "\\\\" + COMMAND_QUICKCODE + "(.*)\\\\" +
 853                     COMMAND_ENDQUICKCODE);
 854             quickcodeRegExp.setMinimal(true);
 855             source.replace(quickcodeRegExp, "");
 856         }
 857
 858         Doc quickDoc(doc.location(),
 859                      doc.location(),
 860                      source,
 861                      (CppCodeParser::topicCommands() + topicCommands() +
 862                       CppCodeParser::otherMetaCommands()) << COMMAND_REPLACE);
 863         quickNode->setDoc(quickDoc, true);
 864         processOtherMetaCommands(quickDoc, quickNode);
 865     }
 866     else {
 867         quickNode->setDoc(doc, true);
 868         processOtherMetaCommands(doc, quickNode);
 869     }
 870 }
 871
 872 bool QsCodeParser::makeFunctionNode(const QString& synopsis,
 873                                      QStringList *parentPathPtr,
 874                                      FunctionNode **funcPtr)
 875 {
 876     QRegExp funcRegExp(
 877             "\\s*([A-Za-z0-9_]+)\\.([A-Za-z0-9_]+)\\s*\\((" +
 878             balancedParens +
 879             ")\\)(?:\\s*:\\s*([A-Za-z0-9_]+))?\\s*");
 880     QRegExp paramRegExp(
 881             "\\s*(\\[)?\\s*(?:([A-Za-z0-9_]+)\\s*:\\s*)?"
 882             "([A-Za-z0-9_]+|\\.\\.\\.)\\s*(\\[)?[\\s\\]]*");
 883
 884     if (!funcRegExp.exactMatch(synopsis))
 885         return false;
 886
 887     ClassNode *classe = (ClassNode*)
 888         qsTre->findNode(QStringList(funcRegExp.cap(1)),Node::Class);
 889     if (classe == 0)
 890         return false;
 891
 892     FunctionNode *clone = new FunctionNode(0, funcRegExp.cap(2));
 893     bool optional = false;
 894
 895     QString paramStr = funcRegExp.cap(3);
 896     QStringList params = paramStr.split(",");
 897     QStringList::ConstIterator p = params.begin();
 898     while (p != params.end()) {
 899         if (paramRegExp.exactMatch(*p)) {
 900             if (!paramRegExp.cap(1).isEmpty())
 901                 optional = true;
 902             clone->addParameter(Parameter(paramRegExp.cap(3),
 903                                           "",
 904                                           paramRegExp.cap(2),
 905                                           optional ? "undefined" : ""));
 906             if (!paramRegExp.cap(4).isEmpty())
 907                 optional = true;
 908         }
 909         else {
 910             delete clone;
 911             return false;
 912         }
 913         ++p;
 914     }
 915     QString returnType = funcRegExp.cap(4);
 916     if (!returnType.isEmpty())
 917         clone->setReturnType(returnType);
 918     if (parentPathPtr != 0)
 919         *parentPathPtr = QStringList() << classe->name();
 920     if (funcPtr != 0) {
 921         *funcPtr = clone;
 922     }
 923     else {
 924         delete clone;
 925     }
 926     return true;
 927 }
 928
 929 bool QsCodeParser::isWord(QChar ch)
 930 {
 931     return ch.isLetterOrNumber() || ch == QChar('_');
 932 }
 933
 934 bool QsCodeParser::leftWordBoundary(const QString& str, int pos)
 935 {
 936     return !isWord(str[pos - 1]) && isWord(str[pos]);
 937 }
 938
 939 bool QsCodeParser::rightWordBoundary(const QString& str, int pos)
 940 {
 941     return isWord(str[pos - 1]) && !isWord(str[pos]);
 942 }
 943
 944 QT_END_NAMESPACE