Changeset 561 for trunk/tools/qdoc3/tree.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• tools/qdoc3/tree.cpp (modified) (25 diffs)

trunk/tools/qdoc3/tree.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the tools applications of the Qt Toolkit.
@@ -21 +22 @@
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -177 +177 @@
 
 /*!
+  Find the node with the specified \a path name of the
+  specified \a type.
  */
 Node *Tree::findNode(const QStringList &path,
@@ -190 +192 @@
 
 /*!
+  Find the node with the specified \a path name of the
+  specified \a type.
  */
 const Node *Tree::findNode(const QStringList &path,
@@ -209 +213 @@
 {
     return const_cast<FunctionNode *>(
-                const_cast<const Tree *>(this)->findFunctionNode(path, relative, findFlags));
+                const_cast<const Tree *>(this)->findFunctionNode(path,
+                                                                 relative,
+                                                                 findFlags));
 }
 
@@ -220 +226 @@
     if (!relative)
         relative = root();
+
     do {
         const Node *node = relative;
@@ -234 +241 @@
                 next = ((InnerNode *) node)->findNode(path.at(i));
 
-            if (!next && node->type() == Node::Class && (findFlags & SearchBaseClasses)) {
+            if (!next && node->type() == Node::Class &&
+                (findFlags & SearchBaseClasses)) {
                 NodeList baseClasses = allBaseClasses(static_cast<const ClassNode *>(node));
                 foreach (const Node *baseClass, baseClasses) {
                     if (i == path.size() - 1)
-                        next = static_cast<const InnerNode *>(baseClass)->
-                                findFunctionNode(path.at(i));
+                        next = static_cast<const InnerNode *>(baseClass)->findFunctionNode(path.at(i));
                     else
                         next = static_cast<const InnerNode *>(baseClass)->findNode(path.at(i));
@@ -250 +257 @@
             node = next;
         }
-        if (node && i == path.size() && node->type() == Node::Function) {
+        if (node && i == path.size() && node->isFunction()) {
             // CppCodeParser::processOtherMetaCommand ensures that reimplemented
             // functions are private.
             const FunctionNode *func = static_cast<const FunctionNode*>(node);
-
             while (func->access() == Node::Private) {
                 const FunctionNode *from = func->reimplementedFrom();
@@ -262 +268 @@
                     else
                         func = from;
-                } else
+                }
+                else
                     break;
             }
@@ -297 +304 @@
     if (parent == 0 || !parent->isInnerNode()) {
         return 0;
-    } else {
+    }
+    else {
         return ((InnerNode *)parent)->findFunctionNode(clone);
     }
@@ -413 +421 @@
 
 /*!
+  This function adds the \a node to the \a group. The group
+  can be listed anywhere using the \e{annotated list} command.
  */
 void Tree::addToGroup(Node *node, const QString &group)
@@ -477 +487 @@
         QString setterName = (*propEntry)[PropertyNode::Setter];
         QString resetterName = (*propEntry)[PropertyNode::Resetter];
+        QString notifierName = (*propEntry)[PropertyNode::Notifier];
 
         NodeList::ConstIterator c = parent->childNodes().begin();
@@ -491 +502 @@
                     } else if (function->name() == resetterName) {
                         property->addFunction(function, PropertyNode::Resetter);
+                    } else if (function->name() == notifierName) {
+                        property->addSignal(function, PropertyNode::Notifier);
                     }
                 }
@@ -564 +577 @@
         FakeNode *fake =
             static_cast<FakeNode*>(findNode(QStringList(i.key()),Node::Fake));
-        if (fake && fake->subType() == FakeNode::Group) {
+        if (fake && fake->subType() == Node::Group) {
             fake->addGroupMember(i.value());
         }
+#if 0        
         else {
             if (prevGroup != i.key())
                 i.value()->doc().location().warning(tr("No such group '%1'").arg(i.key()));
         }
+#endif        
 
         prevGroup = i.key();
@@ -771 +786 @@
     }
     else if (element.nodeName() == "page") {
-        FakeNode::SubType subtype;
+        Node::SubType subtype;
         if (element.attribute("subtype") == "example")
-            subtype = FakeNode::Example;
+            subtype = Node::Example;
         else if (element.attribute("subtype") == "header")
-            subtype = FakeNode::HeaderFile;
+            subtype = Node::HeaderFile;
         else if (element.attribute("subtype") == "file")
-            subtype = FakeNode::File;
+            subtype = Node::File;
         else if (element.attribute("subtype") == "group")
-            subtype = FakeNode::Group;
+            subtype = Node::Group;
         else if (element.attribute("subtype") == "module")
-            subtype = FakeNode::Module;
+            subtype = Node::Module;
         else if (element.attribute("subtype") == "page")
-            subtype = FakeNode::Page;
+            subtype = Node::Page;
         else if (element.attribute("subtype") == "externalpage")
-            subtype = FakeNode::ExternalPage;
+            subtype = Node::ExternalPage;
         else
             return;
@@ -1227 +1242 @@
             const FakeNode *fakeNode = static_cast<const FakeNode*>(node);
             switch (fakeNode->subType()) {
-                case FakeNode::Example:
+                case Node::Example:
                     writer.writeAttribute("subtype", "example");
                     break;
-                case FakeNode::HeaderFile:
+                case Node::HeaderFile:
                     writer.writeAttribute("subtype", "header");
                     break;
-                case FakeNode::File:
+                case Node::File:
                     writer.writeAttribute("subtype", "file");
                     break;
-                case FakeNode::Group:
+                case Node::Group:
                     writer.writeAttribute("subtype", "group");
                     break;
-                case FakeNode::Module:
+                case Node::Module:
                     writer.writeAttribute("subtype", "module");
                     break;
-                case FakeNode::Page:
+                case Node::Page:
                     writer.writeAttribute("subtype", "page");
                     break;
-                case FakeNode::ExternalPage:
+                case Node::ExternalPage:
                     writer.writeAttribute("subtype", "externalpage");
                     break;
@@ -1384 +1399 @@
             if (inner->type() == Node::Fake) {
                 const FakeNode *fakeNode = static_cast<const FakeNode *>(inner);
-                if (fakeNode->subType() == FakeNode::ExternalPage)
+                if (fakeNode->subType() == Node::ExternalPage)
                     external = true;
             }
@@ -1864 +1879 @@
 void Tree::addExternalLink(const QString &url, const Node *relative)
 {
-    FakeNode *fakeNode = new FakeNode(root(), url, FakeNode::ExternalPage);
+    FakeNode *fakeNode = new FakeNode(root(), url, Node::ExternalPage);
     fakeNode->setAccess(Node::Public);
 
@@ -1885 +1900 @@
         return node->url();
 
+    QString parentName;
+    QString anchorRef;
+
     if (node->type() == Node::Namespace) {
 
@@ -1891 +1909 @@
 
         if (!node->fileBase().isEmpty())
-            return node->fileBase() + ".html";
+            parentName = node->fileBase() + ".html";
         else
             return "";
     }
     else if (node->type() == Node::Fake) {
-        return node->fileBase() + ".html";
+#ifdef QDOC_QML
+        if (node->subType() == Node::QmlClass)
+            return "qml-" + node->fileBase() + ".html";
+        else
+#endif
+        parentName = node->fileBase() + ".html";
     }
     else if (node->fileBase().isEmpty())
         return "";
 
-    QString parentName;
     Node *parentNode = 0;
 
@@ -1913 +1935 @@
         case Node::Namespace:
             if (parentNode && !parentNode->name().isEmpty())
-                return parentName.replace(".html", "") + "-"
-                    + node->fileBase().toLower() + ".html";
+                parentName = parentName.replace(".html", "") + "-"
+                           + node->fileBase().toLower() + ".html";
             else
-                return node->fileBase() + ".html";
+                parentName = node->fileBase() + ".html";
+            break;
         case Node::Function:
             {
@@ -1926 +1949 @@
                     static_cast<const FunctionNode *>(node);
 
-                // Functions can be compatibility functions or be obsolete.
-                switch (node->status()) {
-                case Node::Compat:
-                    parentName.replace(".html", "-qt3.html");
-                    break;
-                case Node::Obsolete:
-                    parentName.replace(".html", "-obsolete.html");
-                    break;
-                default:
-                    ;
-                }
-
                 if (functionNode->metaness() == FunctionNode::Dtor)
-                    return parentName + "#dtor." + functionNode->name().mid(1);
-
-                if (functionNode->associatedProperty())
+                    anchorRef = "#dtor." + functionNode->name().mid(1);
+
+                else if (functionNode->associatedProperty())
                     return fullDocumentLocation(functionNode->associatedProperty());
 
-                if (functionNode->overloadNumber() > 1)
-                    return parentName + "#" + functionNode->name()
-                           + "-" + QString::number(functionNode->overloadNumber());
+                else if (functionNode->overloadNumber() > 1)
+                    anchorRef = "#" + functionNode->name()
+                              + "-" + QString::number(functionNode->overloadNumber());
                 else
-                    return parentName + "#" + functionNode->name();
+                    anchorRef = "#" + functionNode->name();
             }
 
@@ -1956 +1967 @@
               HTML anchors, we need to preserve the case.
             */
+            break;
         case Node::Enum:
-            return parentName + "#" + node->name() + "-enum";
+            anchorRef = "#" + node->name() + "-enum";
+            break;
         case Node::Typedef:
-            return parentName + "#" + node->name() + "-typedef";
+            anchorRef = "#" + node->name() + "-typedef";
+            break;
         case Node::Property:
-            return parentName + "#" + node->name() + "-prop";
+            anchorRef = "#" + node->name() + "-prop";
+            break;
         case Node::Variable:
-            return parentName + "#" + node->name() + "-var";
+            anchorRef = "#" + node->name() + "-var";
+            break;
         case Node::Target:
-            return parentName + "#" + Doc::canonicalTitle(node->name());
+            anchorRef = "#" + Doc::canonicalTitle(node->name());
+            break;
         case Node::Fake:
             {
-            QString pageName = node->name();
-            return pageName.replace("/", "-").replace(".", "-") + ".html";
+            /*
+              Use node->fileBase() for fake nodes because they are represented
+              by pages whose file names are lower-case.
+            */
+            parentName = node->fileBase();
+            parentName.replace("/", "-").replace(".", "-");
+            parentName += ".html";
             }
             break;
@@ -1976 +1998 @@
     }
 
-    return "";
+    // Various objects can be compat (deprecated) or obsolete.
+    if (node->type() != Node::Class && node->type() != Node::Namespace) {
+        switch (node->status()) {
+        case Node::Compat:
+            parentName.replace(".html", "-qt3.html");
+            break;
+        case Node::Obsolete:
+            parentName.replace(".html", "-obsolete.html");
+            break;
+        default:
+            ;
+        }
+    }
+
+    return parentName.toLower() + anchorRef;
 }