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   tree.cpp

    44 */

    45 

    46 #include <QtCore>

    47 #include <QDomDocument>

    48 

    49 #include "atom.h"

    50 #include "doc.h"

    51 #include "htmlgenerator.h"

    52 #include "location.h"

    53 #include "node.h"

    54 #include "text.h"

    55 #include "tree.h"

    56 

    57 QT_BEGIN_NAMESPACE

    58 

    59 struct InheritanceBound

    60 {

    61     Node::Access access;

    62     QStringList basePath;

    63     QString dataTypeWithTemplateArgs;

    64     InnerNode *parent;

    65 

    66     InheritanceBound()

    67         : access(Node::Public) { }

    68     InheritanceBound(Node::Access access0,

    69                      const QStringList& basePath0,

    70                      const QString &dataTypeWithTemplateArgs0,

    71                      InnerNode *parent)

    72 	: access(access0), basePath(basePath0),

    73 	  dataTypeWithTemplateArgs(dataTypeWithTemplateArgs0),

    74           parent(parent) { }

    75 };

    76 

    77 struct Target

    78 {

    79     Node *node;

    80     Atom *atom;

    81     int priority;

    82 };

    83 

    84 typedef QMap<PropertyNode::FunctionRole, QString> RoleMap;

    85 typedef QMap<PropertyNode *, RoleMap> PropertyMap;

    86 typedef QMultiMap<QString, Node *> GroupMap;

    87 typedef QMultiHash<QString, FakeNode *> FakeNodeHash;

    88 typedef QMultiHash<QString, Target> TargetHash;

    89 

    90 class TreePrivate

    91 {

    92 public:

    93     QMap<ClassNode *, QList<InheritanceBound> > unresolvedInheritanceMap;

    94     PropertyMap unresolvedPropertyMap;

    95     GroupMap groupMap;

    96     QMultiMap<QString, QString> publicGroupMap;

    97     FakeNodeHash fakeNodesByTitle;

    98     TargetHash targetHash;

    99     QList<QPair<ClassNode*,QString> > basesList;

   100     QList<QPair<FunctionNode*,QString> > relatedList;

   101 };

   102 

   103 /*!

   104   \class Tree

   105  */

   106 

   107 /*!

   108   The default constructor is the only constructor.

   109  */

   110 Tree::Tree()

   111     : roo(0, "")

   112 {

   113     priv = new TreePrivate;

   114 }

   115 

   116 /*!

   117   The destructor deletes the internal, private tree.

   118  */

   119 Tree::~Tree()

   120 {

   121     delete priv;

   122 }

   123 

   124 /*!

   125  */

   126 Node *Tree::findNode(const QStringList &path, Node *relative, int findFlags)

   127 {

   128     return const_cast<Node*>(const_cast<const Tree*>(this)->findNode(path,

   129                                                                      relative,

   130                                                                      findFlags));

   131 }

   132 

   133 /*!

   134  */

   135 const Node *Tree::findNode(const QStringList &path,

   136                            const Node *relative,

   137                            int findFlags) const

   138 {

   139     if (!relative)

   140         relative = root();

   141 

   142     do {

   143         const Node *node = relative;

   144         int i;

   145 

   146         for (i = 0; i < path.size(); ++i) {

   147             if (node == 0 || !node->isInnerNode())

   148                 break;

   149 

   150             const Node *next =

   151                 static_cast<const InnerNode*>(node)->findNode(path.at(i));

   152             if (!next && (findFlags & SearchEnumValues) && i == path.size()-1)

   153                 next = static_cast<const InnerNode*>(node)->findEnumNodeForValue(path.at(i));

   154 

   155             if (!next && node->type() == Node::Class && (findFlags & SearchBaseClasses)) {

   156                 NodeList baseClasses = allBaseClasses(static_cast<const ClassNode *>(node));

   157                 foreach (const Node *baseClass, baseClasses) {

   158                     next = static_cast<const InnerNode *>(baseClass)->findNode(path.at(i));

   159                     if (!next && (findFlags & SearchEnumValues) && i == path.size() - 1)

   160                         next = static_cast<const InnerNode *>(baseClass)

   161                                         ->findEnumNodeForValue(path.at(i));

   162                     if (next)

   163                         break;

   164                 }

   165             }

   166             node = next;

   167         }

   168         if (node && i == path.size()

   169                 && (!(findFlags & NonFunction) || node->type() != Node::Function

   170                     || ((FunctionNode *)node)->metaness() == FunctionNode::MacroWithoutParams))

   171             return node;

   172         relative = relative->parent();

   173     } while (relative);

   174 

   175     return 0;

   176 }

   177 

   178 /*!

   179   Find the node with the specified \a path name of the

   180   specified \a type.

   181  */

   182 Node *Tree::findNode(const QStringList &path,

   183                      Node::Type type,

   184                      Node *relative,

   185                      int findFlags)

   186 {

   187     return const_cast<Node*>(const_cast<const Tree*>(this)->findNode(path,

   188                                                                      type,

   189                                                                      relative,

   190                                                                      findFlags));

   191 }

   192 

   193 /*!

   194   Find the node with the specified \a path name of the

   195   specified \a type.

   196  */

   197 const Node *Tree::findNode(const QStringList &path,

   198                            Node::Type type,

   199                            const Node *relative,

   200                            int findFlags) const

   201 {

   202     const Node *node = findNode(path, relative, findFlags);

   203     if (node != 0 && node->type() == type)

   204         return node;

   205     return 0;

   206 }

   207 

   208 /*!

   209  */

   210 FunctionNode *Tree::findFunctionNode(const QStringList& path,

   211                                      Node *relative,

   212                                      int findFlags)

   213 {

   214     return const_cast<FunctionNode *>(

   215                 const_cast<const Tree *>(this)->findFunctionNode(path,

   216                                                                  relative,

   217                                                                  findFlags));

   218 }

   219 

   220 /*!

   221  */

   222 const FunctionNode *Tree::findFunctionNode(const QStringList &path,

   223                                            const Node *relative,

   224                                            int findFlags) const

   225 {

   226     if (!relative)

   227         relative = root();

   228 

   229     do {

   230         const Node *node = relative;

   231         int i;

   232 

   233         for (i = 0; i < path.size(); ++i) {

   234             if (node == 0 || !node->isInnerNode())

   235                 break;

   236 

   237             const Node *next;

   238             if (i == path.size() - 1)

   239                 next = ((InnerNode *) node)->findFunctionNode(path.at(i));

   240             else

   241                 next = ((InnerNode *) node)->findNode(path.at(i));

   242 

   243             if (!next && node->type() == Node::Class &&

   244                 (findFlags & SearchBaseClasses)) {

   245                 NodeList baseClasses = allBaseClasses(static_cast<const ClassNode *>(node));

   246                 foreach (const Node *baseClass, baseClasses) {

   247                     if (i == path.size() - 1)

   248                         next = static_cast<const InnerNode *>(baseClass)->findFunctionNode(path.at(i));

   249                     else

   250                         next = static_cast<const InnerNode *>(baseClass)->findNode(path.at(i));

   251 

   252                     if (next)

   253                         break;

   254                 }

   255             }

   256 

   257             node = next;

   258         }

   259         if (node && i == path.size() && node->isFunction()) {

   260             // CppCodeParser::processOtherMetaCommand ensures that reimplemented

   261             // functions are private.

   262             const FunctionNode *func = static_cast<const FunctionNode*>(node);

   263             while (func->access() == Node::Private) {

   264                 const FunctionNode *from = func->reimplementedFrom();

   265                 if (from != 0) {

   266                     if (from->access() != Node::Private)

   267                         return from;

   268                     else

   269                         func = from;

   270                 }

   271                 else

   272                     break;

   273             }

   274             return func;

   275         }

   276         relative = relative->parent();

   277     } while (relative);

   278 

   279     return 0;

   280 }

   281 

   282 /*!

   283  */

   284 FunctionNode *Tree::findFunctionNode(const QStringList &parentPath,

   285                                      const FunctionNode *clone,

   286                                      Node *relative,

   287                                      int findFlags)

   288 {

   289     return const_cast<FunctionNode *>(

   290 		const_cast<const Tree *>(this)->findFunctionNode(parentPath,

   291                                                                  clone,

   292                                       				 relative,

   293                                                                  findFlags));

   294 }

   295 

   296 /*!

   297  */

   298 const FunctionNode *Tree::findFunctionNode(const QStringList &parentPath,

   299                                            const FunctionNode *clone,

   300                                            const Node *relative,

   301                                            int findFlags) const

   302 {

   303     const Node *parent = findNode(parentPath, relative, findFlags);

   304     if (parent == 0 || !parent->isInnerNode()) {

   305         return 0;

   306     }

   307     else {

   308         return ((InnerNode *)parent)->findFunctionNode(clone);

   309     }

   310 }

   311 

   312 static const int NumSuffixes = 3;

   313 static const char * const suffixes[NumSuffixes] = { "", "s", "es" };

   314 

   315 /*!

   316  */

   317 const FakeNode *Tree::findFakeNodeByTitle(const QString &title) const

   318 {

   319     for (int pass = 0; pass < NumSuffixes; ++pass) {

   320         FakeNodeHash::const_iterator i =

   321                 priv->fakeNodesByTitle.find(Doc::canonicalTitle(title + suffixes[pass]));

   322         if (i != priv->fakeNodesByTitle.constEnd()) {

   323             FakeNodeHash::const_iterator j = i;

   324             ++j;

   325             if (j != priv->fakeNodesByTitle.constEnd() && j.key() == i.key()) {

   326                 QList<Location> internalLocations;

   327                 while (j != priv->fakeNodesByTitle.constEnd()) {

   328                     if (j.key() == i.key() && j.value()->url().isEmpty())

   329                         internalLocations.append(j.value()->doc().location());

   330                     ++j;

   331                 }

   332                 if (internalLocations.size() > 0) {

   333                     i.value()->doc().location().warning(

   334                         tr("Page '%1' defined in more than one location:").arg(title));

   335                     foreach (const Location &location, internalLocations)

   336                         location.warning(tr("(defined here)"));

   337                 }

   338             }

   339             return i.value();

   340         }

   341     }

   342     return 0;

   343 }

   344 

   345 /*!

   346  */

   347 const Node*

   348 Tree::findUnambiguousTarget(const QString &target, Atom *&atom) const

   349 {

   350     Target bestTarget = {0, 0, INT_MAX};

   351     int numBestTargets = 0;

   352 

   353     for (int pass = 0; pass < NumSuffixes; ++pass) {

   354         TargetHash::const_iterator i =

   355                 priv->targetHash.find(Doc::canonicalTitle(target + suffixes[pass]));

   356         if (i != priv->targetHash.constEnd()) {

   357             TargetHash::const_iterator j = i;

   358             do {

   359                 const Target &candidate = j.value();

   360                 if (candidate.priority < bestTarget.priority) {

   361                     bestTarget = candidate;

   362                     numBestTargets = 1;

   363                 } else if (candidate.priority == bestTarget.priority) {

   364                     ++numBestTargets;

   365                 }

   366                 ++j;

   367             } while (j != priv->targetHash.constEnd() && j.key() == i.key());

   368 

   369             if (numBestTargets == 1) {

   370                 atom = bestTarget.atom;

   371                 return bestTarget.node;

   372             }

   373         }

   374     }

   375     return 0;

   376 }

   377 

   378 /*!

   379  */

   380 Atom *Tree::findTarget(const QString &target, const Node *node) const

   381 {

   382     for (int pass = 0; pass < NumSuffixes; ++pass) {

   383         QString key = Doc::canonicalTitle(target + suffixes[pass]);

   384         TargetHash::const_iterator i = priv->targetHash.find(key);

   385 

   386         if (i != priv->targetHash.constEnd()) {

   387             do {

   388                 if (i.value().node == node)

   389                     return i.value().atom;

   390                 ++i;

   391             } while (i != priv->targetHash.constEnd() && i.key() == key);

   392         }

   393     }

   394     return 0;

   395 }

   396 

   397 /*!

   398  */

   399 void Tree::addBaseClass(ClassNode *subclass, Node::Access access,

   400                         const QStringList &basePath,

   401                         const QString &dataTypeWithTemplateArgs,

   402                         InnerNode *parent)

   403 {

   404     priv->unresolvedInheritanceMap[subclass].append(

   405 	    InheritanceBound(access,

   406                              basePath,

   407                              dataTypeWithTemplateArgs,

   408                              parent)

   409                                                    );

   410 }

   411 

   412 

   413 /*!

   414  */

   415 void Tree::addPropertyFunction(PropertyNode *property,

   416                                const QString &funcName,

   417                                PropertyNode::FunctionRole funcRole)

   418 {

   419     priv->unresolvedPropertyMap[property].insert(funcRole, funcName);

   420 }

   421 

   422 /*!

   423   This function adds the \a node to the \a group. The group

   424   can be listed anywhere using the \e{annotated list} command.

   425  */

   426 void Tree::addToGroup(Node *node, const QString &group)

   427 {

   428     priv->groupMap.insert(group, node);

   429 }

   430 

   431 /*!

   432  */

   433 QMultiMap<QString, Node *> Tree::groups() const

   434 {

   435     return priv->groupMap;

   436 }

   437 

   438 /*!

   439  */

   440 void Tree::addToPublicGroup(Node *node, const QString &group)

   441 {

   442     priv->publicGroupMap.insert(node->name(), group);

   443     addToGroup(node, group);

   444 }

   445 

   446 /*!

   447  */

   448 QMultiMap<QString, QString> Tree::publicGroups() const

   449 {

   450     return priv->publicGroupMap;

   451 }

   452 

   453 /*!

   454  */

   455 void Tree::resolveInheritance(NamespaceNode *rootNode)

   456 {

   457     if (!rootNode)

   458         rootNode = root();

   459 

   460     for (int pass = 0; pass < 2; pass++) {

   461         NodeList::ConstIterator c = rootNode->childNodes().begin();

   462         while (c != rootNode->childNodes().end()) {

   463             if ((*c)->type() == Node::Class)

   464                 resolveInheritance(pass, (ClassNode *) *c);

   465             else if ((*c)->type() == Node::Namespace) {

   466                 NamespaceNode *ns = static_cast<NamespaceNode*>(*c);

   467                 resolveInheritance(ns);

   468             }

   469             ++c;

   470         }

   471         if (rootNode == root())

   472             priv->unresolvedInheritanceMap.clear();

   473     }

   474 }

   475 

   476 /*!

   477  */

   478 void Tree::resolveProperties()

   479 {

   480     PropertyMap::ConstIterator propEntry;

   481 

   482     propEntry = priv->unresolvedPropertyMap.begin();

   483     while (propEntry != priv->unresolvedPropertyMap.end()) {

   484         PropertyNode *property = propEntry.key();

   485         InnerNode *parent = property->parent();

   486         QString getterName = (*propEntry)[PropertyNode::Getter];

   487         QString setterName = (*propEntry)[PropertyNode::Setter];

   488         QString resetterName = (*propEntry)[PropertyNode::Resetter];

   489         QString notifierName = (*propEntry)[PropertyNode::Notifier];

   490 

   491         NodeList::ConstIterator c = parent->childNodes().begin();

   492         while (c != parent->childNodes().end()) {

   493             if ((*c)->type() == Node::Function) {

   494                 FunctionNode *function = static_cast<FunctionNode *>(*c);

   495                 if (function->access() == property->access() &&

   496                     (function->status() == property->status() ||

   497                      function->doc().isEmpty())) {

   498                     if (function->name() == getterName) {

   499                         property->addFunction(function, PropertyNode::Getter);

   500                     } else if (function->name() == setterName) {

   501                         property->addFunction(function, PropertyNode::Setter);

   502                     } else if (function->name() == resetterName) {

   503                         property->addFunction(function, PropertyNode::Resetter);

   504                     } else if (function->name() == notifierName) {

   505                         property->addSignal(function, PropertyNode::Notifier);

   506                     }

   507                 }

   508             }

   509             ++c;

   510         }

   511         ++propEntry;

   512     }

   513 

   514     propEntry = priv->unresolvedPropertyMap.begin();

   515     while (propEntry != priv->unresolvedPropertyMap.end()) {

   516         PropertyNode *property = propEntry.key();

   517         // redo it to set the property functions

   518         if (property->overriddenFrom())

   519             property->setOverriddenFrom(property->overriddenFrom());

   520         ++propEntry;

   521     }

   522 

   523     priv->unresolvedPropertyMap.clear();

   524 }

   525 

   526 /*!

   527  */

   528 void Tree::resolveInheritance(int pass, ClassNode *classe)

   529 {

   530     if (pass == 0) {

   531 	QList<InheritanceBound> bounds = priv->unresolvedInheritanceMap[classe];

   532 	QList<InheritanceBound>::ConstIterator b = bounds.begin();

   533 	while (b != bounds.end()) {

   534 	    ClassNode *baseClass = (ClassNode*)findNode((*b).basePath,

   535                                                         Node::Class);

   536             if (!baseClass && (*b).parent)

   537                 baseClass = (ClassNode*)findNode((*b).basePath,

   538                                                  Node::Class,

   539                                                  (*b).parent);

   540 	    if (baseClass)

   541 		classe->addBaseClass((*b).access,

   542                                      baseClass,

   543                                      (*b).dataTypeWithTemplateArgs);

   544 	    ++b;

   545 	}

   546     }

   547     else {

   548 	NodeList::ConstIterator c = classe->childNodes().begin();

   549 	while (c != classe->childNodes().end()) {

   550 	    if ((*c)->type() == Node::Function) {

   551 		FunctionNode *func = (FunctionNode *) *c;

   552 		FunctionNode *from = findVirtualFunctionInBaseClasses(classe, func);

   553 		if (from != 0) {

   554 		    if (func->virtualness() == FunctionNode::NonVirtual)

   555 			func->setVirtualness(FunctionNode::ImpureVirtual);

   556 		    func->setReimplementedFrom(from);

   557 		}

   558 	    }

   559             else if ((*c)->type() == Node::Property) {

   560                 fixPropertyUsingBaseClasses(classe, static_cast<PropertyNode *>(*c));

   561             }

   562             ++c;

   563         }

   564     }

   565 }

   566 

   567 /*!

   568  */

   569 void Tree::resolveGroups()

   570 {

   571     GroupMap::const_iterator i;

   572     QString prevGroup;

   573     for (i = priv->groupMap.constBegin(); i != priv->groupMap.constEnd(); ++i) {

   574         if (i.value()->access() == Node::Private)

   575             continue;

   576 

   577         FakeNode *fake =

   578             static_cast<FakeNode*>(findNode(QStringList(i.key()),Node::Fake));

   579         if (fake && fake->subType() == Node::Group) {

   580             fake->addGroupMember(i.value());

   581         }

   582 #if 0        

   583         else {

   584             if (prevGroup != i.key())

   585                 i.value()->doc().location().warning(tr("No such group '%1'").arg(i.key()));

   586         }

   587 #endif        

   588 

   589         prevGroup = i.key();

   590     }

   591 

   592     //priv->groupMap.clear();

   593 }

   594 

   595 /*!

   596  */

   597 void Tree::resolveTargets()

   598 {

   599     // need recursion

   600 

   601     foreach (Node *child, roo.childNodes()) {

   602         if (child->type() == Node::Fake) {

   603             FakeNode *node = static_cast<FakeNode *>(child);

   604             priv->fakeNodesByTitle.insert(Doc::canonicalTitle(node->title()), node);

   605         }

   606 

   607         if (child->doc().hasTableOfContents()) {

   608             const QList<Atom *> &toc = child->doc().tableOfContents();

   609             Target target;

   610             target.node = child;

   611             target.priority = 3;

   612 

   613             for (int i = 0; i < toc.size(); ++i) {

   614                 target.atom = toc.at(i);

   615                 QString title = Text::sectionHeading(target.atom).toString();

   616                 if (!title.isEmpty())

   617                     priv->targetHash.insert(Doc::canonicalTitle(title), target);

   618             }

   619         }

   620         if (child->doc().hasKeywords()) {

   621             const QList<Atom *> &keywords = child->doc().keywords();

   622             Target target;

   623             target.node = child;

   624             target.priority = 1;

   625 

   626             for (int i = 0; i < keywords.size(); ++i) {

   627                 target.atom = keywords.at(i);

   628                 priv->targetHash.insert(Doc::canonicalTitle(target.atom->string()), target);

   629             }

   630         }

   631         if (child->doc().hasTargets()) {

   632             const QList<Atom *> &toc = child->doc().targets();

   633             Target target;

   634             target.node = child;

   635             target.priority = 2;

   636 

   637             for (int i = 0; i < toc.size(); ++i) {

   638                 target.atom = toc.at(i);

   639                 priv->targetHash.insert(Doc::canonicalTitle(target.atom->string()), target);

   640             }

   641         }

   642     }

   643 }

   644 

   645 /*!

   646  */

   647 void Tree::fixInheritance(NamespaceNode *rootNode)

   648 {

   649     if (!rootNode)

   650         rootNode = root();

   651 

   652     NodeList::ConstIterator c = rootNode->childNodes().begin();

   653     while (c != rootNode->childNodes().end()) {

   654         if ((*c)->type() == Node::Class)

   655             static_cast<ClassNode *>(*c)->fixBaseClasses();

   656         else if ((*c)->type() == Node::Namespace) {

   657             NamespaceNode *ns = static_cast<NamespaceNode*>(*c);

   658             fixInheritance(ns);

   659         }

   660         ++c;

   661     }

   662 }

   663 

   664 /*!

   665  */

   666 FunctionNode *Tree::findVirtualFunctionInBaseClasses(ClassNode *classe,

   667                                                      FunctionNode *clone)

   668 {

   669     QList<RelatedClass>::ConstIterator r = classe->baseClasses().begin();

   670     while (r != classe->baseClasses().end()) {

   671         FunctionNode *func;

   672         if (((func = findVirtualFunctionInBaseClasses((*r).node, clone)) != 0 ||

   673               (func = (*r).node->findFunctionNode(clone)) != 0)) {

   674             if (func->virtualness() != FunctionNode::NonVirtual)

   675                 return func;

   676         }

   677          ++r;

   678     }

   679     return 0;

   680 }

   681 

   682 /*!

   683  */

   684 void Tree::fixPropertyUsingBaseClasses(ClassNode *classe,

   685                                        PropertyNode *property)

   686 {

   687     QList<RelatedClass>::const_iterator r = classe->baseClasses().begin();

   688     while (r != classe->baseClasses().end()) {

   689 	PropertyNode *baseProperty =

   690             static_cast<PropertyNode *>(r->node->findNode(property->name(),

   691                                                           Node::Property));

   692         if (baseProperty) {

   693             fixPropertyUsingBaseClasses(r->node, baseProperty);

   694             property->setOverriddenFrom(baseProperty);

   695         }

   696         else {

   697             fixPropertyUsingBaseClasses(r->node, property);

   698         }

   699          ++r;

   700     }

   701 }

   702 

   703 /*!

   704  */

   705 NodeList Tree::allBaseClasses(const ClassNode *classe) const

   706 {

   707     NodeList result;

   708     foreach (const RelatedClass &r, classe->baseClasses()) {

   709         result += r.node;

   710         result += allBaseClasses(r.node);

   711     }

   712     return result;

   713 }

   714 

   715 /*!

   716  */

   717 void Tree::readIndexes(const QStringList &indexFiles)

   718 {

   719     foreach (const QString &indexFile, indexFiles)

   720         readIndexFile(indexFile);

   721 }

   722 

   723 /*!

   724   Read the QDomDocument at \a path and get the index from it.

   725  */

   726 void Tree::readIndexFile(const QString &path)

   727 {

   728     QFile file(path);

   729     if (file.open(QFile::ReadOnly)) {

   730         QDomDocument document;

   731         document.setContent(&file);

   732         file.close();

   733 

   734         QDomElement indexElement = document.documentElement();

   735         QString indexUrl = indexElement.attribute("url", "");

   736         priv->basesList.clear();

   737         priv->relatedList.clear();

   738 

   739         // Scan all elements in the XML file, constructing a map that contains

   740         // base classes for each class found.

   741 

   742         QDomElement child = indexElement.firstChildElement();

   743         while (!child.isNull()) {

   744             readIndexSection(child, root(), indexUrl);

   745             child = child.nextSiblingElement();

   746         }

   747 

   748         // Now that all the base classes have been found for this index,

   749         // arrange them into an inheritance hierarchy.

   750 

   751         resolveIndex();

   752     }

   753 }

   754 

   755 /*!

   756  */

   757 void Tree::readIndexSection(const QDomElement &element,

   758                             InnerNode *parent,

   759                             const QString &indexUrl)

   760 {

   761     QString name = element.attribute("name");

   762     QString href = element.attribute("href");

   763 

   764     Node *section;

   765     Location location;

   766 

   767     if (element.nodeName() == "namespace") {

   768         section = new NamespaceNode(parent, name);

   769 

   770         if (!indexUrl.isEmpty())

   771             location = Location(indexUrl + "/" + name.toLower() + ".html");

   772         else if (!indexUrl.isNull())

   773             location = Location(name.toLower() + ".html");

   774 

   775     }

   776     else if (element.nodeName() == "class") {

   777         section = new ClassNode(parent, name);

   778         priv->basesList.append(QPair<ClassNode*,QString>(

   779             static_cast<ClassNode*>(section), element.attribute("bases")));

   780 

   781         if (!indexUrl.isEmpty())

   782             location = Location(indexUrl + "/" + name.toLower() + ".html");

   783         else if (!indexUrl.isNull())

   784             location = Location(name.toLower() + ".html");

   785 

   786     }

   787     else if (element.nodeName() == "page") {

   788         Node::SubType subtype;

   789         if (element.attribute("subtype") == "example")

   790             subtype = Node::Example;

   791         else if (element.attribute("subtype") == "header")

   792             subtype = Node::HeaderFile;

   793         else if (element.attribute("subtype") == "file")

   794             subtype = Node::File;

   795         else if (element.attribute("subtype") == "group")

   796             subtype = Node::Group;

   797         else if (element.attribute("subtype") == "module")

   798             subtype = Node::Module;

   799         else if (element.attribute("subtype") == "page")

   800             subtype = Node::Page;

   801         else if (element.attribute("subtype") == "externalpage")

   802             subtype = Node::ExternalPage;

   803         else

   804             return;

   805 

   806         FakeNode *fakeNode = new FakeNode(parent, name, subtype);

   807         fakeNode->setTitle(element.attribute("title"));

   808 

   809         if (element.hasAttribute("location"))

   810             name = element.attribute("location", "");

   811 

   812         if (!indexUrl.isEmpty())

   813             location = Location(indexUrl + "/" + name);

   814         else if (!indexUrl.isNull())

   815             location = Location(name);

   816 

   817         section = fakeNode;

   818 

   819     }

   820     else if (element.nodeName() == "enum") {

   821         EnumNode *enumNode = new EnumNode(parent, name);

   822 

   823         if (!indexUrl.isEmpty())

   824             location =

   825                 Location(indexUrl + "/" + parent->name().toLower() + ".html");

   826         else if (!indexUrl.isNull())

   827             location = Location(parent->name().toLower() + ".html");

   828 

   829         QDomElement child = element.firstChildElement("value");

   830         while (!child.isNull()) {

   831             EnumItem item(child.attribute("name"), child.attribute("value"));

   832             enumNode->addItem(item);

   833             child = child.nextSiblingElement("value");

   834         }

   835 

   836         section = enumNode;

   837 

   838     } else if (element.nodeName() == "typedef") {

   839         section = new TypedefNode(parent, name);

   840 

   841         if (!indexUrl.isEmpty())

   842             location =

   843                 Location(indexUrl + "/" + parent->name().toLower() + ".html");

   844         else if (!indexUrl.isNull())

   845             location = Location(parent->name().toLower() + ".html");

   846 

   847     }

   848     else if (element.nodeName() == "property") {

   849         section = new PropertyNode(parent, name);

   850 

   851         if (!indexUrl.isEmpty())

   852             location =

   853                 Location(indexUrl + "/" + parent->name().toLower() + ".html");

   854         else if (!indexUrl.isNull())

   855             location = Location(parent->name().toLower() + ".html");

   856 

   857     } else if (element.nodeName() == "function") {

   858         FunctionNode::Virtualness virt;

   859         if (element.attribute("virtual") == "non")

   860             virt = FunctionNode::NonVirtual;

   861         else if (element.attribute("virtual") == "impure")

   862             virt = FunctionNode::ImpureVirtual;

   863         else if (element.attribute("virtual") == "pure")

   864             virt = FunctionNode::PureVirtual;

   865         else

   866             return;

   867 

   868         FunctionNode::Metaness meta;

   869         if (element.attribute("meta") == "plain")

   870             meta = FunctionNode::Plain;

   871         else if (element.attribute("meta") == "signal")

   872             meta = FunctionNode::Signal;

   873         else if (element.attribute("meta") == "slot")

   874             meta = FunctionNode::Slot;

   875         else if (element.attribute("meta") == "constructor")

   876             meta = FunctionNode::Ctor;

   877         else if (element.attribute("meta") == "destructor")

   878             meta = FunctionNode::Dtor;

   879         else if (element.attribute("meta") == "macro")

   880             meta = FunctionNode::MacroWithParams;

   881         else if (element.attribute("meta") == "macrowithparams")

   882             meta = FunctionNode::MacroWithParams;

   883         else if (element.attribute("meta") == "macrowithoutparams")

   884             meta = FunctionNode::MacroWithoutParams;

   885         else

   886             return;

   887 

   888         FunctionNode *functionNode = new FunctionNode(parent, name);

   889         functionNode->setReturnType(element.attribute("return"));

   890         functionNode->setVirtualness(virt);

   891         functionNode->setMetaness(meta);

   892         functionNode->setConst(element.attribute("const") == "true");

   893         functionNode->setStatic(element.attribute("static") == "true");

   894         functionNode->setOverload(element.attribute("overload") == "true");

   895 

   896         if (element.hasAttribute("relates")

   897             && element.attribute("relates") != parent->name()) {

   898             priv->relatedList.append(

   899                 QPair<FunctionNode*,QString>(functionNode,

   900                                              element.attribute("relates")));

   901         }

   902 

   903         QDomElement child = element.firstChildElement("parameter");

   904         while (!child.isNull()) {

   905             // Do not use the default value for the parameter; it is not

   906             // required, and has been known to cause problems.

   907             Parameter parameter(child.attribute("left"),

   908                                 child.attribute("right"),

   909                                 child.attribute("name"),

   910                                 ""); // child.attribute("default")

   911             functionNode->addParameter(parameter);

   912             child = child.nextSiblingElement("parameter");

   913         }

   914 

   915         section = functionNode;

   916 

   917         if (!indexUrl.isEmpty())

   918             location =

   919                 Location(indexUrl + "/" + parent->name().toLower() + ".html");

   920         else if (!indexUrl.isNull())

   921             location = Location(parent->name().toLower() + ".html");

   922 

   923     }

   924     else if (element.nodeName() == "variable") {

   925         section = new VariableNode(parent, name);

   926 

   927         if (!indexUrl.isEmpty())

   928             location = Location(indexUrl + "/" + parent->name().toLower() + ".html");

   929         else if (!indexUrl.isNull())

   930             location = Location(parent->name().toLower() + ".html");

   931 

   932     }

   933     else if (element.nodeName() == "keyword") {

   934         Target target;

   935         target.node = parent;

   936         target.priority = 1;

   937         target.atom = new Atom(Atom::Target, name);

   938         priv->targetHash.insert(name, target);

   939         return;

   940 

   941     }

   942     else if (element.nodeName() == "target") {

   943         Target target;

   944         target.node = parent;

   945         target.priority = 2;

   946         target.atom = new Atom(Atom::Target, name);

   947         priv->targetHash.insert(name, target);

   948         return;

   949 

   950     }

   951     else if (element.nodeName() == "contents") {

   952         Target target;

   953         target.node = parent;

   954         target.priority = 3;

   955         target.atom = new Atom(Atom::Target, name);

   956         priv->targetHash.insert(name, target);

   957         return;

   958 

   959     }

   960     else

   961         return;

   962 

   963     QString access = element.attribute("access");

   964     if (access == "public")

   965         section->setAccess(Node::Public);

   966     else if (access == "protected")

   967         section->setAccess(Node::Protected);

   968     else if (access == "private")

   969         section->setAccess(Node::Private);

   970     else

   971         section->setAccess(Node::Public);

   972 

   973     if (element.nodeName() != "page") {

   974         QString threadSafety = element.attribute("threadsafety");

   975         if (threadSafety == "non-reentrant")

   976             section->setThreadSafeness(Node::NonReentrant);

   977         else if (threadSafety == "reentrant")

   978             section->setThreadSafeness(Node::Reentrant);

   979         else if (threadSafety == "thread safe")

   980             section->setThreadSafeness(Node::ThreadSafe);

   981         else

   982             section->setThreadSafeness(Node::UnspecifiedSafeness);

   983     }

   984     else

   985         section->setThreadSafeness(Node::UnspecifiedSafeness);

   986 

   987     QString status = element.attribute("status");

   988     if (status == "compat")

   989         section->setStatus(Node::Compat);

   990     else if (status == "obsolete")

   991         section->setStatus(Node::Obsolete);

   992     else if (status == "deprecated")

   993         section->setStatus(Node::Deprecated);

   994     else if (status == "preliminary")

   995         section->setStatus(Node::Preliminary);

   996     else if (status == "commendable")

   997         section->setStatus(Node::Commendable);

   998     else if (status == "internal")

   999         section->setStatus(Node::Internal);

  1000     else if (status == "main")

  1001         section->setStatus(Node::Main);

  1002     else

  1003         section->setStatus(Node::Commendable);

  1004 

  1005     section->setModuleName(element.attribute("module"));

  1006     if (!indexUrl.isEmpty()) {

  1007         if (indexUrl.startsWith("."))

  1008             section->setUrl(href);

  1009         else

  1010             section->setUrl(indexUrl + "/" + href);

  1011     }

  1012 

  1013     // Create some content for the node.

  1014     QSet<QString> emptySet;

  1015 

  1016     Doc doc(location, location, " ", emptySet); // placeholder

  1017     section->setDoc(doc);

  1018 

  1019     if (section->isInnerNode()) {

  1020         InnerNode *inner = static_cast<InnerNode*>(section);

  1021         if (inner) {

  1022             QDomElement child = element.firstChildElement();

  1023 

  1024             while (!child.isNull()) {

  1025                 if (element.nodeName() == "class")

  1026                     readIndexSection(child, inner, indexUrl);

  1027                 else if (element.nodeName() == "page")

  1028                     readIndexSection(child, inner, indexUrl);

  1029                 else if (element.nodeName() == "namespace" && !name.isEmpty())

  1030                     // The root node in the index is a namespace with an empty name.

  1031                     readIndexSection(child, inner, indexUrl);

  1032                 else

  1033                     readIndexSection(child, parent, indexUrl);

  1034 

  1035                 child = child.nextSiblingElement();

  1036             }

  1037         }

  1038     }

  1039 }

  1040 

  1041 /*!

  1042  */

  1043 QString Tree::readIndexText(const QDomElement &element)

  1044 {

  1045     QString text;

  1046     QDomNode child = element.firstChild();

  1047     while (!child.isNull()) {

  1048         if (child.isText())

  1049             text += child.toText().nodeValue();

  1050         child = child.nextSibling();

  1051     }

  1052     return text;

  1053 }

  1054 

  1055 /*!

  1056  */

  1057 void Tree::resolveIndex()

  1058 {

  1059     QPair<ClassNode*,QString> pair;

  1060 

  1061     foreach (pair, priv->basesList) {

  1062         foreach (const QString &base, pair.second.split(",")) {

  1063             Node *baseClass = root()->findNode(base, Node::Class);

  1064             if (baseClass) {

  1065                 pair.first->addBaseClass(Node::Public,

  1066                                          static_cast<ClassNode*>(baseClass));

  1067             }

  1068         }

  1069     }

  1070 

  1071     QPair<FunctionNode*,QString> relatedPair;

  1072 

  1073     foreach (relatedPair, priv->relatedList) {

  1074         Node *classNode = root()->findNode(relatedPair.second, Node::Class);

  1075         if (classNode)

  1076             relatedPair.first->setRelates(static_cast<ClassNode*>(classNode));

  1077     }

  1078 }

  1079 

  1080 /*!

  1081   Generate the index section with the given \a writer for the \a node

  1082   specified, returning true if an element was written; otherwise returns

  1083   false.

  1084  */

  1085 bool Tree::generateIndexSection(QXmlStreamWriter &writer,

  1086                                 const Node *node,

  1087                                 bool generateInternalNodes) const

  1088 {

  1089     if (!node->url().isEmpty())

  1090         return false;

  1091 

  1092     QString nodeName;

  1093     switch (node->type()) {

  1094         case Node::Namespace:

  1095             nodeName = "namespace";

  1096             break;

  1097         case Node::Class:

  1098             nodeName = "class";

  1099             break;

  1100         case Node::Fake:

  1101             nodeName = "page";

  1102             break;

  1103         case Node::Enum:

  1104             nodeName = "enum";

  1105             break;

  1106         case Node::Typedef:

  1107             nodeName = "typedef";

  1108             break;

  1109         case Node::Property:

  1110             nodeName = "property";

  1111             break;

  1112         case Node::Function:

  1113             nodeName = "function";

  1114             break;

  1115         case Node::Variable:

  1116             nodeName = "variable";

  1117             break;

  1118         case Node::Target:

  1119             nodeName = "target";

  1120             break;

  1121         default:

  1122             return false;

  1123     }

  1124 

  1125     QString access;

  1126     switch (node->access()) {

  1127         case Node::Public:

  1128             access = "public";

  1129             break;

  1130         case Node::Protected:

  1131             access = "protected";

  1132             break;

  1133         case Node::Private:

  1134             // Do not include private non-internal nodes in the index.

  1135             // (Internal public and protected nodes are marked as private