/**************************************************************************** ** ** Copyright (C) 2019 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the tools applications of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:GPL-EXCEPT$ ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and The Qt Company. For licensing terms ** and conditions see https://www.qt.io/terms-conditions. For further ** information use the contact form at https://www.qt.io/contact-us. ** ** GNU General Public License Usage ** Alternatively, this file may be used under the terms of the GNU ** General Public License version 3 as published by the Free Software ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT ** included in the packaging of this file. Please review the following ** information to ensure the GNU General Public License requirements will ** be met: https://www.gnu.org/licenses/gpl-3.0.html. ** ** $QT_END_LICENSE$ ** ****************************************************************************/ #include "tree.h" #include "doc.h" #include "htmlgenerator.h" #include "location.h" #include "node.h" #include "qdocdatabase.h" #include "text.h" #include #include QT_BEGIN_NAMESPACE /*! \class Tree This class constructs and maintains a tree of instances of the subclasses of Node. This class is now private. Only class QDocDatabase has access. Please don't change this. If you must access class Tree, do it though the pointer to the singleton QDocDatabase. Tree is being converted to a forest. A static member provides a map of Tree *values with the module names as the keys. There is one Tree in the map for each index file read, and there is one tree that is not in the map for the module whose documentation is being generated. */ /*! Constructs a Tree. \a qdb is the pointer to the singleton qdoc database that is constructing the tree. This might not be necessary, and it might be removed later. \a camelCaseModuleName is the project name for this tree as it appears in the qdocconf file. */ Tree::Tree(const QString &camelCaseModuleName, QDocDatabase *qdb) : treeHasBeenAnalyzed_(false), docsHaveBeenGenerated_(false), linkCount_(0), camelCaseModuleName_(camelCaseModuleName), physicalModuleName_(camelCaseModuleName.toLower()), qdb_(qdb), root_(nullptr, QString()), targetListMap_(nullptr) { root_.setPhysicalModuleName(physicalModuleName_); root_.setTree(this); const auto &config = Config::instance(); if (config.getBool(CONFIG_WRITEQAPAGES)) targetListMap_ = new TargetListMap; } /*! Destroys the Tree. The root node is a data member of this object, so its destructor is called. The destructor of each child node is called, and these destructors are recursive. Thus the entire tree is destroyed. There are two maps of targets, keywords, and contents. One map is indexed by ref, the other by title. The ref is just the canonical form of the title. Both maps use the same set of TargetRec objects as the values, so the destructor only deletes the values from one of the maps. Then it clears both maps. */ Tree::~Tree() { for (auto i = nodesByTargetRef_.begin(); i != nodesByTargetRef_.end(); ++i) { delete i.value(); } nodesByTargetRef_.clear(); nodesByTargetTitle_.clear(); const auto &config = Config::instance(); if (config.getBool(CONFIG_WRITEQAPAGES) && targetListMap_) { for (auto target = targetListMap_->begin(); target != targetListMap_->end(); ++target) { TargetList *tlist = target.value(); if (tlist) { for (auto *location : qAsConst(*tlist)) delete location; } delete tlist; } } } /* API members */ /*! Calls findClassNode() first with \a path and \a start. If it finds a node, the node is returned. If not, it calls findNamespaceNode() with the same parameters. The result is returned. */ Node *Tree::findNodeForInclude(const QStringList &path) const { Node *n = findClassNode(path); if (n == nullptr) n = findNamespaceNode(path); return n; } /*! This function searches this tree for an Aggregate node with the specified \a name. It returns the pointer to that node or nullptr. We might need to split the name on '::' but we assume the name is a single word at the moment. */ Aggregate *Tree::findAggregate(const QString &name) { QStringList path = name.split(QLatin1String("::")); return static_cast(findNodeRecursive(path, 0, const_cast(root()), &Node::isFirstClassAggregate)); } /*! Find the C++ class node named \a path. Begin the search at the \a start node. If the \a start node is 0, begin the search at the root of the tree. Only a C++ class node named \a path is acceptible. If one is not found, 0 is returned. */ ClassNode *Tree::findClassNode(const QStringList &path, const Node *start) const { if (start == nullptr) start = const_cast(root()); return static_cast(findNodeRecursive(path, 0, start, &Node::isClassNode)); } /*! Find the Namespace node named \a path. Begin the search at the root of the tree. Only a Namespace node named \a path is acceptible. If one is not found, 0 is returned. */ NamespaceNode *Tree::findNamespaceNode(const QStringList &path) const { Node *start = const_cast(root()); return static_cast(findNodeRecursive(path, 0, start, &Node::isNamespace)); } /*! Find the Qml type node named \a path. Begin the search at the \a start node. If the \a start node is 0, begin the search at the root of the tree. Only a Qml type node named <\a path is acceptible. If one is not found, 0 is returned. */ QmlTypeNode *Tree::findQmlTypeNode(const QStringList &path) { /* If the path contains one or two double colons ("::"), check first to see if the first two path strings refer to a QML element. If they do, path[0] will be the QML module identifier, and path[1] will be the QML type. If the anser is yes, the reference identifies a QML class node. */ if (path.size() >= 2 && !path[0].isEmpty()) { QmlTypeNode *qcn = qdb_->findQmlType(path[0], path[1]); if (qcn != nullptr) return qcn; } return static_cast(findNodeRecursive(path, 0, root(), &Node::isQmlType)); } /*! This function searches for the node specified by \a path. The matching node can be one of several different types including a C++ class, a C++ namespace, or a C++ header file. I'm not sure if it can be a QML type, but if that is a possibility, the code can easily accommodate it. If a matching node is found, a pointer to it is returned. Otherwise 0 is returned. */ Aggregate *Tree::findRelatesNode(const QStringList &path) { Node *n = findNodeRecursive(path, 0, root(), &Node::isRelatableType); return (((n != nullptr) && n->isAggregate()) ? static_cast(n) : nullptr); } /*! Inserts function name \a funcName and function role \a funcRole into the property function map for the specified \a property. */ void Tree::addPropertyFunction(PropertyNode *property, const QString &funcName, PropertyNode::FunctionRole funcRole) { unresolvedPropertyMap[property].insert(funcRole, funcName); } /*! This function resolves C++ inheritance and reimplementation settings for each C++ class node found in the tree beginning at \a n. It also calls itself recursively for each C++ class node or namespace node it encounters. This function does not resolve QML inheritance. */ void Tree::resolveBaseClasses(Aggregate *n) { for (auto it = n->constBegin(); it != n->constEnd(); ++it) { if ((*it)->isClassNode()) { ClassNode *cn = static_cast(*it); QVector &bases = cn->baseClasses(); for (auto &base : bases) { if (base.node_ == nullptr) { Node *n = qdb_->findClassNode(base.path_); /* If the node for the base class was not found, the reason might be that the subclass is in a namespace and the base class is in the same namespace, but the base class name was not qualified with the namespace name. That is the case most of the time. Then restart the search at the parent of the subclass node (the namespace node) using the unqualified base class name. */ if (n == nullptr) { Aggregate *parent = cn->parent(); if (parent != nullptr) // Exclude the root namespace if (parent->isNamespace() && !parent->name().isEmpty()) n = findClassNode(base.path_, parent); } if (n != nullptr) { ClassNode *bcn = static_cast(n); base.node_ = bcn; bcn->addDerivedClass(base.access_, cn); } } } resolveBaseClasses(cn); } else if ((*it)->isNamespace()) { resolveBaseClasses(static_cast(*it)); } } } /*! */ void Tree::resolvePropertyOverriddenFromPtrs(Aggregate *n) { for (auto node = n->constBegin(); node != n->constEnd(); ++node) { if ((*node)->isClassNode()) { ClassNode *cn = static_cast(*node); for (auto property = cn->constBegin(); property != cn->constEnd(); ++property) { if ((*property)->isProperty()) cn->resolvePropertyOverriddenFromPtrs(static_cast(*property)); } resolvePropertyOverriddenFromPtrs(cn); } else if ((*node)->isNamespace()) { resolvePropertyOverriddenFromPtrs(static_cast(*node)); } } } /*! */ void Tree::resolveProperties() { for (auto propEntry = unresolvedPropertyMap.constBegin(); propEntry != unresolvedPropertyMap.constEnd(); ++propEntry) { PropertyNode *property = propEntry.key(); Aggregate *parent = property->parent(); QString getterName = (*propEntry)[PropertyNode::Getter]; QString setterName = (*propEntry)[PropertyNode::Setter]; QString resetterName = (*propEntry)[PropertyNode::Resetter]; QString notifierName = (*propEntry)[PropertyNode::Notifier]; for (auto it = parent->constBegin(); it != parent->constEnd(); ++it) { if ((*it)->isFunction()) { FunctionNode *function = static_cast(*it); if (function->access() == property->access() && (function->status() == property->status() || function->doc().isEmpty())) { if (function->name() == getterName) { property->addFunction(function, PropertyNode::Getter); } else if (function->name() == setterName) { property->addFunction(function, PropertyNode::Setter); } else if (function->name() == resetterName) { property->addFunction(function, PropertyNode::Resetter); } else if (function->name() == notifierName) { property->addSignal(function, PropertyNode::Notifier); } } } } } for (auto propEntry = unresolvedPropertyMap.constBegin(); propEntry != unresolvedPropertyMap.constEnd(); ++propEntry) { PropertyNode *property = propEntry.key(); // redo it to set the property functions if (property->overriddenFrom()) property->setOverriddenFrom(property->overriddenFrom()); } unresolvedPropertyMap.clear(); } /*! For each QML class node that points to a C++ class node, follow its C++ class node pointer and set the C++ class node's QML class node pointer back to the QML class node. */ void Tree::resolveCppToQmlLinks() { const NodeList &children = root_.childNodes(); for (auto *child : children) { if (child->isQmlType() || child->isJsType()) { QmlTypeNode *qcn = static_cast(child); ClassNode *cn = const_cast(qcn->classNode()); if (cn) cn->setQmlElement(qcn); } } } /*! For each C++ class node, resolve any \c using clauses that appeared in the class declaration. */ void Tree::resolveUsingClauses() { const NodeList &children = root_.childNodes(); for (auto *child : children) { if (child->isClassNode()) { ClassNode *cn = static_cast(child); QVector &usingClauses = cn->usingClauses(); for (auto &usingClause : usingClauses) { if (usingClause.node() == nullptr) { const Node *n = qdb_->findFunctionNode(usingClause.signature(), cn, Node::CPP); if (n != nullptr) usingClause.setNode(n); } } } } } /*! Traverse this Tree and for each ClassNode found, remove from its list of base classes any that are marked private or internal. When a class is removed from a base class list, promote its public pase classes to be base classes of the class where the base class was removed. This is done for documentation purposes. The function is recursive on namespace nodes. */ void Tree::removePrivateAndInternalBases(NamespaceNode *rootNode) { if (rootNode == nullptr) rootNode = root(); for (auto node = rootNode->constBegin(); node != rootNode->constEnd(); ++node) { if ((*node)->isClassNode()) static_cast(*node)->removePrivateAndInternalBases(); else if ((*node)->isNamespace()) removePrivateAndInternalBases(static_cast(*node)); } } /*! */ ClassList Tree::allBaseClasses(const ClassNode *classNode) const { ClassList result; const auto &baseClasses = classNode->baseClasses(); for (const auto &relatedClass : baseClasses) { if (relatedClass.node_ != nullptr) { result += relatedClass.node_; result += allBaseClasses(relatedClass.node_); } } return result; } /*! Find the node with the specified \a path name that is of the specified \a type and \a subtype. Begin the search at the \a start node. If the \a start node is 0, begin the search at the tree root. \a subtype is not used unless \a type is \c{Page}. */ Node *Tree::findNodeByNameAndType(const QStringList &path, bool (Node::*isMatch)() const) const { return findNodeRecursive(path, 0, root(), isMatch); } /*! Recursive search for a node identified by \a path. Each path element is a name. \a pathIndex specifies the index of the name in \a path to try to match. \a start is the node whose children shoulod be searched for one that has that name. Each time a match is found, increment the \a pathIndex and call this function recursively. If the end of the path is reached (i.e. if a matching node is found for each name in the \a path), the \a type must match the type of the last matching node, and if the type is \e{Page}, the \a subtype must match as well. If the algorithm is successful, the pointer to the final node is returned. Otherwise 0 is returned. */ Node *Tree::findNodeRecursive(const QStringList &path, int pathIndex, const Node *start, bool (Node::*isMatch)() const) const { if (start == nullptr || path.isEmpty()) return nullptr; Node *node = const_cast(start); if (!node->isAggregate()) return ((pathIndex >= path.size()) ? node : nullptr); Aggregate *current = static_cast(node); const NodeList &children = current->childNodes(); const QString &name = path.at(pathIndex); for (auto *node : children) { if (node == nullptr) continue; if (node->name() == name) { if (pathIndex + 1 >= path.size()) { if ((node->*(isMatch))()) return node; continue; } else { // Search the children of n for the next name in the path. node = findNodeRecursive(path, pathIndex + 1, node, isMatch); if (node != nullptr) return node; } } } return nullptr; } /*! Searches the tree for a node that matches the \a path plus the \a target. The search begins at \a start and moves up the parent chain from there, or, if \a start is 0, the search begins at the root. The \a flags can indicate whether to search base classes and/or the enum values in enum types. \a genus can be a further restriction on what kind of node is an acceptible match, i.e. CPP or QML. If a matching node is found, \a ref is an output parameter that is set to the HTML reference to use for the link. */ const Node *Tree::findNodeForTarget(const QStringList &path, const QString &target, const Node *start, int flags, Node::Genus genus, QString &ref) const { const Node *node = nullptr; if ((genus == Node::DontCare) || (genus == Node::DOC)) { node = findPageNodeByTitle(path.at(0)); if (node) { if (!target.isEmpty()) { ref = getRef(target, node); if (ref.isEmpty()) node = nullptr; } if (node) return node; } } node = findUnambiguousTarget(path.join(QLatin1String("::")), genus, ref); if (node) { if (!target.isEmpty()) { ref = getRef(target, node); if (ref.isEmpty()) node = nullptr; } if (node) return node; } const Node *current = start; if (current == nullptr) current = root(); /* If the path contains one or two double colons ("::"), check first to see if the first two path strings refer to a QML element. If they do, path[0] will be the QML module identifier, and path[1] will be the QML type. If the answer is yes, the reference identifies a QML type node. */ int path_idx = 0; if (((genus == Node::QML) || (genus == Node::DontCare)) && (path.size() >= 2) && !path[0].isEmpty()) { QmlTypeNode *qcn = lookupQmlType(QString(path[0] + "::" + path[1])); if (qcn) { current = qcn; if (path.size() == 2) { if (!target.isEmpty()) { ref = getRef(target, current); if (!ref.isEmpty()) return current; return nullptr; } else return current; } path_idx = 2; } } while (current != nullptr) { if (current->isAggregate()) { // Should this be isPageNode() ??? const Node *node = matchPathAndTarget(path, path_idx, target, current, flags, genus, ref); if (node) return node; } current = current->parent(); path_idx = 0; } return nullptr; } /*! First, the \a path is used to find a node. The \a path matches some part of the node's fully quallified name. If the \a target is not empty, it must match a target in the matching node. If the matching of the \a path and the \a target (if present) is successful, \a ref is set from the \a target, and the pointer to the matching node is returned. \a idx is the index into the \a path where to begin the matching. The function is recursive with idx being incremented for each recursive call. The matching node must be of the correct \a genus, i.e. either QML or C++, but \a genus can be set to \c DontCare. \a flags indicates whether to search base classes and whether to search for an enum value. \a node points to the node where the search should begin, assuming the \a path is a not a fully-qualified name. \a node is most often the root of this Tree. */ const Node *Tree::matchPathAndTarget(const QStringList &path, int idx, const QString &target, const Node *node, int flags, Node::Genus genus, QString &ref) const { /* If the path has been matched, then if there is a target, try to match the target. If there is a target, but you can't match it at the end of the path, give up; return 0. */ if (idx == path.size()) { if (!target.isEmpty()) { ref = getRef(target, node); if (ref.isEmpty()) return nullptr; } if (node->isFunction() && node->name() == node->parent()->name()) node = node->parent(); return node; } QString name = path.at(idx); if (node->isAggregate()) { NodeVector nodes; static_cast(node)->findChildren(name, nodes); for (const auto *node : qAsConst(nodes)) { if (genus != Node::DontCare && node->genus() != genus) continue; const Node *t = matchPathAndTarget(path, idx + 1, target, node, flags, genus, ref); if (t && !t->isPrivate()) return t; } } if (target.isEmpty()) { if ((idx) == (path.size() - 1) && node->isAggregate() && (flags & SearchEnumValues)) { const Node *t = static_cast(node)->findEnumNodeForValue(path.at(idx)); if (t) return t; } } if (((genus == Node::CPP) || (genus == Node::DontCare)) && node->isClassNode() && (flags & SearchBaseClasses)) { const ClassList bases = allBaseClasses(static_cast(node)); for (const auto *base : bases) { const Node *t = matchPathAndTarget(path, idx, target, base, flags, genus, ref); if (t && !t->isPrivate()) return t; if (target.isEmpty()) { if ((idx) == (path.size() - 1) && (flags & SearchEnumValues)) { t = base->findEnumNodeForValue(path.at(idx)); if (t) return t; } } } } return nullptr; } /*! Searches the tree for a node that matches the \a path. The search begins at \a start but can move up the parent chain recursively if no match is found. The \a flags are used to restrict the search. */ const Node *Tree::findNode(const QStringList &path, const Node *start, int flags, Node::Genus genus) const { const Node *current = start; if (current == nullptr) current = root(); do { const Node *node = current; int i; int start_idx = 0; /* If the path contains one or two double colons ("::"), check first to see if the first two path strings refer to a QML element. If they do, path[0] will be the QML module identifier, and path[1] will be the QML type. If the answer is yes, the reference identifies a QML type node. */ if (((genus == Node::QML) || (genus == Node::DontCare)) && (path.size() >= 2) && !path[0].isEmpty()) { QmlTypeNode *qcn = lookupQmlType(QString(path[0] + "::" + path[1])); if (qcn != nullptr) { node = qcn; if (path.size() == 2) return node; start_idx = 2; } } for (i = start_idx; i < path.size(); ++i) { if (node == nullptr || !node->isAggregate()) break; // Clear the TypesOnly flag until the last path segment, as e.g. namespaces are not // types. We also ignore module nodes as they are not aggregates and thus have no // children. int tmpFlags = (i < path.size() - 1) ? (flags & ~TypesOnly) | IgnoreModules : flags; const Node *next = static_cast(node)->findChildNode(path.at(i), genus, tmpFlags); if ((next == nullptr) && (flags & SearchEnumValues) && i == path.size() - 1) { next = static_cast(node)->findEnumNodeForValue(path.at(i)); } if ((next == nullptr) && ((genus == Node::CPP) || (genus == Node::DontCare)) && node->isClassNode() && (flags & SearchBaseClasses)) { const ClassList bases = allBaseClasses(static_cast(node)); for (const auto *base : bases) { next = base->findChildNode(path.at(i), genus, tmpFlags); if ((next == nullptr) && (flags & SearchEnumValues) && i == path.size() - 1) next = base->findEnumNodeForValue(path.at(i)); if (next != nullptr) break; } } node = next; } if ((node != nullptr) && i == path.size()) return node; current = current->parent(); } while (current != nullptr); return nullptr; } /*! This function searches for a node with a canonical title constructed from \a target. If the node it finds is \a node, it returns the ref from that node. Otherwise it returns an empty string. */ QString Tree::getRef(const QString &target, const Node *node) const { auto it = nodesByTargetTitle_.constFind(target); if (it != nodesByTargetTitle_.constEnd()) { do { if (it.value()->node_ == node) return it.value()->ref_; ++it; } while (it != nodesByTargetTitle_.constEnd() && it.key() == target); } QString key = Doc::canonicalTitle(target); it = nodesByTargetRef_.constFind(key); if (it != nodesByTargetRef_.constEnd()) { do { if (it.value()->node_ == node) return it.value()->ref_; ++it; } while (it != nodesByTargetRef_.constEnd() && it.key() == key); } return QString(); } /*! Inserts a new target into the target table. \a name is the key. The target record contains the \a type, a pointer to the \a node, the \a priority. and a canonicalized form of the \a name, which is later used. */ void Tree::insertTarget(const QString &name, const QString &title, TargetRec::TargetType type, Node *node, int priority) { TargetRec *target = new TargetRec(name, title, type, node, priority); nodesByTargetRef_.insert(name, target); nodesByTargetTitle_.insert(title, target); } /*! */ void Tree::resolveTargets(Aggregate *root) { for (auto *child : root->childNodes()) { if (child->isTextPageNode()) { PageNode *node = static_cast(child); QString key = node->title(); if (!key.isEmpty()) { if (key.contains(QChar(' '))) key = Doc::canonicalTitle(key); QList nodes = pageNodesByTitle_.values(key); bool alreadyThere = false; if (!nodes.empty()) { for (const auto &node_ : nodes) { if (node_->isExternalPage()) { if (node->name() == node_->name()) { alreadyThere = true; break; } } } } if (!alreadyThere) pageNodesByTitle_.insert(key, node); } } if (child->doc().hasTableOfContents()) { const QVector &toc = child->doc().tableOfContents(); for (int i = 0; i < toc.size(); ++i) { QString ref = refForAtom(toc.at(i)); QString title = Text::sectionHeading(toc.at(i)).toString(); if (!ref.isEmpty() && !title.isEmpty()) { QString key = Doc::canonicalTitle(title); TargetRec *target = new TargetRec(ref, title, TargetRec::Contents, child, 3); nodesByTargetRef_.insert(key, target); nodesByTargetTitle_.insert(title, target); } } } if (child->doc().hasKeywords()) { const QVector &keywords = child->doc().keywords(); for (int i = 0; i < keywords.size(); ++i) { QString ref = refForAtom(keywords.at(i)); QString title = keywords.at(i)->string(); if (!ref.isEmpty() && !title.isEmpty()) { TargetRec *target = new TargetRec(ref, title, TargetRec::Keyword, child, 1); nodesByTargetRef_.insert(Doc::canonicalTitle(title), target); nodesByTargetTitle_.insert(title, target); } } } if (child->doc().hasTargets()) { const QVector &targets = child->doc().targets(); for (int i = 0; i < targets.size(); ++i) { QString ref = refForAtom(targets.at(i)); QString title = targets.at(i)->string(); if (!ref.isEmpty() && !title.isEmpty()) { QString key = Doc::canonicalTitle(title); TargetRec *target = new TargetRec(ref, title, TargetRec::Target, child, 2); nodesByTargetRef_.insert(key, target); nodesByTargetTitle_.insert(title, target); } } } if (child->isAggregate()) resolveTargets(static_cast(child)); } } /*! This function searches for a \a target anchor node. If it finds one, it sets \a ref and returns the found node. */ const Node *Tree::findUnambiguousTarget(const QString &target, Node::Genus genus, QString &ref) const { int numBestTargets = 0; TargetRec *bestTarget = nullptr; QVector bestTargetList; QString key = target; for (auto it = nodesByTargetTitle_.find(key); it != nodesByTargetTitle_.constEnd(); ++it) { if (it.key() != key) break; TargetRec *candidate = it.value(); if ((genus == Node::DontCare) || (genus == candidate->genus())) { if (!bestTarget || (candidate->priority_ < bestTarget->priority_)) { bestTarget = candidate; bestTargetList.clear(); bestTargetList.append(candidate); numBestTargets = 1; } else if (candidate->priority_ == bestTarget->priority_) { bestTargetList.append(candidate); ++numBestTargets; } } } if (bestTarget) { ref = bestTarget->ref_; return bestTarget->node_; } numBestTargets = 0; bestTarget = nullptr; key = Doc::canonicalTitle(target); for (auto it = nodesByTargetRef_.find(key); it != nodesByTargetRef_.constEnd(); ++it) { if (it.key() != key) break; TargetRec *candidate = it.value(); if ((genus == Node::DontCare) || (genus == candidate->genus())) { if (!bestTarget || (candidate->priority_ < bestTarget->priority_)) { bestTarget = candidate; bestTargetList.clear(); bestTargetList.append(candidate); numBestTargets = 1; } else if (candidate->priority_ == bestTarget->priority_) { bestTargetList.append(candidate); ++numBestTargets; } } } if (bestTarget) { ref = bestTarget->ref_; return bestTarget->node_; } ref.clear(); return nullptr; } /*! This function searches for a node with the specified \a title. */ const PageNode *Tree::findPageNodeByTitle(const QString &title) const { PageNodeMultiMap::const_iterator it; if (title.contains(QChar(' '))) it = pageNodesByTitle_.constFind(Doc::canonicalTitle(title)); else it = pageNodesByTitle_.constFind(title); if (it != pageNodesByTitle_.constEnd()) { /* Reporting all these duplicate section titles is probably overkill. We should report the duplicate file and let that suffice. */ PageNodeMultiMap::const_iterator j = it; ++j; if (j != pageNodesByTitle_.constEnd() && j.key() == it.key()) { while (j != pageNodesByTitle_.constEnd()) { if (j.key() == it.key() && j.value()->url().isEmpty()) { break; // Just report one duplicate for now. } ++j; } if (j != pageNodesByTitle_.cend()) { it.value()->location().warning("This page title exists in more than one file: " + title); j.value()->location().warning("[It also exists here]"); } } return it.value(); } return nullptr; } /*! Returns a canonical title for the \a atom, if the \a atom is a SectionLeft or a Target. */ QString Tree::refForAtom(const Atom *atom) { if (atom) { if (atom->type() == Atom::SectionLeft) return Doc::canonicalTitle(Text::sectionHeading(atom).toString()); if ((atom->type() == Atom::Target) || (atom->type() == Atom::Keyword)) return Doc::canonicalTitle(atom->string()); } return QString(); } /*! \fn const CNMap &Tree::groups() const Returns a const reference to the collection of all group nodes. */ /*! \fn const ModuleMap &Tree::modules() const Returns a const reference to the collection of all module nodes. */ /*! \fn const QmlModuleMap &Tree::qmlModules() const Returns a const reference to the collection of all QML module nodes. */ /*! Returns a pointer to the collection map specified by \a type. Returns null if \a type is not specified. */ CNMap *Tree::getCollectionMap(Node::NodeType type) { switch (type) { case Node::Group: return &groups_; case Node::Module: return &modules_; case Node::QmlModule: return &qmlModules_; case Node::JsModule: return &jsModules_; default: break; } return nullptr; } /*! Searches this tree for a collection named \a name with the specified \a type. If the collection is found, a pointer to it is returned. If a collection is not found, null is returned. */ CollectionNode *Tree::getCollection(const QString &name, Node::NodeType type) { CNMap *map = getCollectionMap(type); if (map) { auto it = map->constFind(name); if (it != map->cend()) return it.value(); } return nullptr; } /*! Find the group, module, QML module, or JavaScript module named \a name and return a pointer to that collection node. \a type specifies which kind of collection node you want. If a collection node with the specified \a name and \a type is not found, a new one is created, and the pointer to the new one is returned. If a new collection node is created, its parent is the tree root, and the new collection node is marked \e{not seen}. \a genus must be specified, i.e. it must not be \c{DontCare}. If it is \c{DontCare}, 0 is returned, which is a programming error. */ CollectionNode *Tree::findCollection(const QString &name, Node::NodeType type) { CNMap *m = getCollectionMap(type); if (!m) // error return nullptr; auto it = m->constFind(name); if (it != m->cend()) return it.value(); CollectionNode *cn = new CollectionNode(type, root(), name); cn->markNotSeen(); m->insert(name, cn); return cn; } /*! \fn CollectionNode *Tree::findGroup(const QString &name) Find the group node named \a name and return a pointer to it. If the group node is not found, add a new group node named \a name and return a pointer to the new one. If a new group node is added, its parent is the tree root, and the new group node is marked \e{not seen}. */ /*! \fn CollectionNode *Tree::findModule(const QString &name) Find the module node named \a name and return a pointer to it. If a matching node is not found, add a new module node named \a name and return a pointer to that one. If a new module node is added, its parent is the tree root, and the new module node is marked \e{not seen}. */ /*! \fn CollectionNode *Tree::findQmlModule(const QString &name) Find the QML module node named \a name and return a pointer to it. If a matching node is not found, add a new QML module node named \a name and return a pointer to that one. If a new QML module node is added, its parent is the tree root, and the new node is marked \e{not seen}. */ /*! \fn CollectionNode *Tree::findJsModule(const QString &name) Find the JavaScript module named \a name and return a pointer to it. If a matching node is not found, add a new JavaScript module node named \a name and return a pointer to that one. If a new JavaScript module node is added, its parent is the tree root, and the new node is marked \e{not seen}. */ /*! \fn CollectionNode *Tree::addGroup(const QString &name) Looks up the group node named \a name in the collection of all group nodes. If a match is found, a pointer to the node is returned. Otherwise, a new group node named \a name is created and inserted into the collection, and the pointer to that node is returned. */ /*! \fn CollectionNode *Tree::addModule(const QString &name) Looks up the module node named \a name in the collection of all module nodes. If a match is found, a pointer to the node is returned. Otherwise, a new module node named \a name is created and inserted into the collection, and the pointer to that node is returned. */ /*! \fn CollectionNode *Tree::addQmlModule(const QString &name) Looks up the QML module node named \a name in the collection of all QML module nodes. If a match is found, a pointer to the node is returned. Otherwise, a new QML module node named \a name is created and inserted into the collection, and the pointer to that node is returned. */ /*! \fn CollectionNode *Tree::addJsModule(const QString &name) Looks up the JavaScript module node named \a name in the collection of all JavaScript module nodes. If a match is found, a pointer to the node is returned. Otherwise, a new JavaScrpt module node named \a name is created and inserted into the collection, and the pointer to that node is returned. */ /*! Looks up the group node named \a name in the collection of all group nodes. If a match is not found, a new group node named \a name is created and inserted into the collection. Then append \a node to the group's members list, and append the group name to the list of group names in \a node. The parent of \a node is not changed by this function. Returns a pointer to the group node. */ CollectionNode *Tree::addToGroup(const QString &name, Node *node) { CollectionNode *cn = findGroup(name); if (!node->isInternal()) { cn->addMember(node); node->appendGroupName(name); } return cn; } /*! Looks up the module node named \a name in the collection of all module nodes. If a match is not found, a new module node named \a name is created and inserted into the collection. Then append \a node to the module's members list. The parent of \a node is not changed by this function. Returns the module node. */ CollectionNode *Tree::addToModule(const QString &name, Node *node) { CollectionNode *cn = findModule(name); cn->addMember(node); node->setPhysicalModuleName(name); return cn; } /*! Looks up the QML module named \a name. If it isn't there, create it. Then append \a node to the QML module's member list. The parent of \a node is not changed by this function. Returns the pointer to the QML module node. */ CollectionNode *Tree::addToQmlModule(const QString &name, Node *node) { QStringList qmid; QStringList dotSplit; QStringList blankSplit = name.split(QLatin1Char(' ')); qmid.append(blankSplit[0]); if (blankSplit.size() > 1) { qmid.append(blankSplit[0] + blankSplit[1]); dotSplit = blankSplit[1].split(QLatin1Char('.')); qmid.append(blankSplit[0] + dotSplit[0]); } CollectionNode *cn = findQmlModule(blankSplit[0]); cn->addMember(node); node->setQmlModule(cn); if (node->isQmlType()) { QmlTypeNode *n = static_cast(node); for (int i = 0; i < qmid.size(); ++i) { QString key = qmid[i] + "::" + node->name(); insertQmlType(key, n); } } return cn; } /*! Looks up the QML module named \a name. If it isn't there, create it. Then append \a node to the QML module's member list. The parent of \a node is not changed by this function. Returns the pointer to the QML module node. */ CollectionNode *Tree::addToJsModule(const QString &name, Node *node) { QStringList qmid; QStringList dotSplit; QStringList blankSplit = name.split(QLatin1Char(' ')); qmid.append(blankSplit[0]); if (blankSplit.size() > 1) { qmid.append(blankSplit[0] + blankSplit[1]); dotSplit = blankSplit[1].split(QLatin1Char('.')); qmid.append(blankSplit[0] + dotSplit[0]); } CollectionNode *cn = findJsModule(blankSplit[0]); cn->addMember(node); node->setQmlModule(cn); if (node->isJsType()) { QmlTypeNode *n = static_cast(node); for (int i = 0; i < qmid.size(); ++i) { QString key = qmid[i] + "::" + node->name(); insertQmlType(key, n); } } return cn; } /*! If the QML type map does not contain \a key, insert node \a n with the specified \a key. */ void Tree::insertQmlType(const QString &key, QmlTypeNode *n) { if (!qmlTypeMap_.contains(key)) qmlTypeMap_.insert(key, n); } /*! Finds the function node with the specifried name \a path that also has the specified \a parameters and returns a pointer to the the first matching function node if one is found. This function begins searching the tree at \a relative for the \l {FunctionNode} {function node} identified by \a path that has the specified \a parameters. The \a flags are used to restrict the search. If a matching node is found, a pointer to it is returned. Otherwise, nullis returned. If \a relative is ull, the search begins at the tree root. */ const FunctionNode *Tree::findFunctionNode(const QStringList &path, const Parameters ¶meters, const Node *relative, Node::Genus genus) const { if (path.size() == 3 && !path[0].isEmpty() && ((genus == Node::QML) || (genus == Node::DontCare))) { QmlTypeNode *qcn = lookupQmlType(QString(path[0] + "::" + path[1])); if (qcn == nullptr) { QStringList p(path[1]); Node *n = findNodeByNameAndType(p, &Node::isQmlType); if ((n != nullptr) && (n->isQmlType() || n->isJsType())) qcn = static_cast(n); } if (qcn != nullptr) return static_cast(qcn->findFunctionChild(path[2], parameters)); } if (relative == nullptr) relative = root(); else if (genus != Node::DontCare) { if (genus != relative->genus()) relative = root(); } do { Node *node = const_cast(relative); int i; for (i = 0; i < path.size(); ++i) { if (node == nullptr || !node->isAggregate()) break; Aggregate *aggregate = static_cast(node); Node *next = nullptr; if (i == path.size() - 1) next = aggregate->findFunctionChild(path.at(i), parameters); else next = aggregate->findChildNode(path.at(i), genus); if ((next == nullptr) && aggregate->isClassNode()) { const ClassList bases = allBaseClasses(static_cast(aggregate)); for (auto *base : bases) { if (i == path.size() - 1) next = base->findFunctionChild(path.at(i), parameters); else next = base->findChildNode(path.at(i), genus); if (next != nullptr) break; } } node = next; } // for (i = 0; i < path.size(); ++i) if (node && i == path.size() && node->isFunction()) { // A function node was found at the end of the path. // If it is not marked private, return it. If it is // marked private, then if it overrides a function, // find that function instead because it might not // be marked private. If all the overloads are // marked private, return the original function node. // This should be replace with findOverriddenFunctionNode(). const FunctionNode *fn = static_cast(node); const FunctionNode *FN = fn; while (FN->isPrivate() && !FN->overridesThis().isEmpty()) { QStringList path = FN->overridesThis().split("::"); FN = qdb_->findFunctionNode(path, parameters, relative, genus); if (FN == nullptr) break; if (!FN->isPrivate()) return FN; } return fn; } relative = relative->parent(); } while (relative); return nullptr; } /*! Generate a target of the form link-nnn, where the nnn is the current link count for this tree. This target string is returned. It will be output as an HTML anchor just before an HTML link to the node \a t. The node \a t */ QString Tree::getNewLinkTarget(const Node *locNode, const Node *t, const QString &fileName, QString &text, bool broken) { QString physicalModuleName; if (t != nullptr && !broken) { Tree *tree = t->tree(); if (tree != this) tree->incrementLinkCount(); physicalModuleName = tree->physicalModuleName(); } else physicalModuleName = "broken"; incrementLinkCount(); QString target = QString("qa-target-%1").arg(-(linkCount())); TargetLoc *tloc = new TargetLoc(locNode, target, fileName, text, broken); TargetList *tList = nullptr; auto it = targetListMap_->find(physicalModuleName); if (it == targetListMap_->end()) { tList = new TargetList; it = targetListMap_->insert(physicalModuleName, tList); } else tList = it.value(); tList->append(tloc); return target; } /*! Look up the target list for the specified \a module and return a pointer to it. */ TargetList *Tree::getTargetList(const QString &module) { return targetListMap_->value(module); } /*! Search this tree recursively from \a parent to find a function node with the specified \a tag. If no function node is found with the required \a tag, return 0. */ FunctionNode *Tree::findFunctionNodeForTag(const QString &tag, Aggregate *parent) { if (parent == nullptr) parent = root(); const NodeList &children = parent->childNodes(); for (Node *n : children) { if (n != nullptr && n->isFunction() && n->hasTag(tag)) return static_cast(n); } for (Node *n : children) { if (n != nullptr && n->isAggregate()) { n = findFunctionNodeForTag(tag, static_cast(n)); if (n != nullptr) return static_cast(n); } } return nullptr; } /*! There should only be one macro node for macro name \a t. The macro node is not built until the \macro command is seen. */ FunctionNode *Tree::findMacroNode(const QString &t, const Aggregate *parent) { if (parent == nullptr) parent = root(); const NodeList &children = parent->childNodes(); for (Node *n : children) { if (n != nullptr && (n->isMacro() || n->isFunction()) && n->name() == t) return static_cast(n); } for (Node *n : children) { if (n != nullptr && n->isAggregate()) { FunctionNode *fn = findMacroNode(t, static_cast(n)); if (fn != nullptr) return fn; } } return nullptr; } /*! Add the class and struct names in \a arg to the \e {don't document} map. */ void Tree::addToDontDocumentMap(QString &arg) { arg.remove(QChar('(')); arg.remove(QChar(')')); QString t = arg.simplified(); QStringList sl = t.split(QChar(' ')); if (sl.isEmpty()) return; for (const QString &s : sl) { if (!dontDocumentMap_.contains(s)) dontDocumentMap_.insert(s, nullptr); } } /*! The \e {don't document} map has been loaded with the names of classes and structs in the current module that are not documented and should not be documented. Now traverse the map, and for each class or struct name, find the class node that represents that class or struct and mark it with the \C DontDocument status. This results in a map of the class and struct nodes in the module that are in the public API but are not meant to be used by anyone. They are only used internally, but for one reason or another, they must have public visibility. */ void Tree::markDontDocumentNodes() { for (auto it = dontDocumentMap_.begin(); it != dontDocumentMap_.end(); ++it) { Aggregate *node = findAggregate(it.key()); if (node != nullptr) node->setStatus(Node::DontDocument); } } QT_END_NAMESPACE