summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/tools/qdoc/codemarker.cpp34
-rw-r--r--src/tools/qdoc/codemarker.h6
-rw-r--r--src/tools/qdoc/cppcodemarker.cpp86
-rw-r--r--src/tools/qdoc/tree.cpp48
4 files changed, 96 insertions, 78 deletions
diff --git a/src/tools/qdoc/codemarker.cpp b/src/tools/qdoc/codemarker.cpp
index 7cc6b631f6..9fe91d93e8 100644
--- a/src/tools/qdoc/codemarker.cpp
+++ b/src/tools/qdoc/codemarker.cpp
@@ -396,7 +396,7 @@ void CodeMarker::insert(FastSection &fastSection,
bool irrelevant = false;
bool inheritedMember = false;
if (!node->relates()) {
- if (node->parent() != (const InnerNode*)fastSection.innerNode && !node->parent()->isAbstract()) {
+ if (node->parent() != fastSection.parent_) { // && !node->parent()->isAbstract()) {
if (node->type() != Node::QmlProperty) {
inheritedMember = true;
}
@@ -468,7 +468,7 @@ void CodeMarker::insert(FastSection& fastSection,
(parent->subType() == Node::QmlPropertyGroup)) {
parent = parent->parent();
}
- inheritedMember = (parent != (const InnerNode*)fastSection.innerNode);
+ inheritedMember = (parent != fastSection.parent_);
if (!inheritedMember || style == Subpage) {
QString key = sortName(node);
@@ -488,24 +488,24 @@ void CodeMarker::insert(FastSection& fastSection,
}
/*!
- Returns true if \a node represents a reimplemented member function.
- If it is, then it is inserted in the reimplemented member map in the
- section \a fs. And, the test is only performed if \a status is \e OK.
- Otherwise, false is returned.
+ Returns true if \a node represents a reimplemented member
+ function in the class of the FastSection \a fs. If it is
+ a reimplemented function, then it is inserted into the
+ reimplemented member map in \a fs. The test is performed
+ only if \a status is \e OK. True is returned if \a node
+ is inserted into the map. Otherwise, false is returned.
*/
bool CodeMarker::insertReimpFunc(FastSection& fs, Node* node, Status status)
{
- if (node->access() == Node::Private)
- return false;
-
- const FunctionNode* fn = static_cast<const FunctionNode*>(node);
- if ((fn->reimplementedFrom() != 0) && (status == Okay)) {
- bool inherited = (!fn->relates() && (fn->parent() != (const InnerNode*)fs.innerNode));
- if (!inherited) {
- QString key = sortName(fn);
- if (!fs.reimpMemberMap.contains(key)) {
- fs.reimpMemberMap.insert(key,node);
- return true;
+ if ((node->access() != Node::Private) && (node->relates() == 0)) {
+ const FunctionNode* fn = static_cast<const FunctionNode*>(node);
+ if ((fn->reimplementedFrom() != 0) && (status == Okay)) {
+ if (fn->parent() == fs.parent_) {
+ QString key = sortName(fn);
+ if (!fs.reimpMemberMap.contains(key)) {
+ fs.reimpMemberMap.insert(key,node);
+ return true;
+ }
}
}
}
diff --git a/src/tools/qdoc/codemarker.h b/src/tools/qdoc/codemarker.h
index 0e699a62bf..14d33d37a0 100644
--- a/src/tools/qdoc/codemarker.h
+++ b/src/tools/qdoc/codemarker.h
@@ -82,7 +82,7 @@ struct Section
struct FastSection
{
- const InnerNode *innerNode;
+ const InnerNode *parent_;
QString name;
QString divClass;
QString singularMember;
@@ -91,12 +91,12 @@ struct FastSection
QMap<QString, Node *> reimpMemberMap;
QList<QPair<InnerNode *, int> > inherited;
- FastSection(const InnerNode *innerNode0,
+ FastSection(const InnerNode *parent,
const QString& name0,
const QString& divClass0,
const QString& singularMember0,
const QString& pluralMember0)
- : innerNode(innerNode0),
+ : parent_(parent),
name(name0),
divClass(divClass0),
singularMember(singularMember0),
diff --git a/src/tools/qdoc/cppcodemarker.cpp b/src/tools/qdoc/cppcodemarker.cpp
index 3abe4c2a65..ccff1c18ca 100644
--- a/src/tools/qdoc/cppcodemarker.cpp
+++ b/src/tools/qdoc/cppcodemarker.cpp
@@ -449,74 +449,74 @@ QList<Section> CppCodeMarker::sections(const InnerNode *inner,
QList<Section> sections;
if (inner->type() == Node::Class) {
- const ClassNode *classe = static_cast<const ClassNode *>(inner);
+ const ClassNode *classNode = static_cast<const ClassNode *>(inner);
if (style == Summary) {
- FastSection privateFunctions(classe,
+ FastSection privateFunctions(classNode,
"Private Functions",
QString(),
"private function",
"private functions");
- FastSection privateSlots(classe, "Private Slots", QString(), "private slot", "private slots");
- FastSection privateTypes(classe, "Private Types", QString(), "private type", "private types");
- FastSection protectedFunctions(classe,
+ FastSection privateSlots(classNode, "Private Slots", QString(), "private slot", "private slots");
+ FastSection privateTypes(classNode, "Private Types", QString(), "private type", "private types");
+ FastSection protectedFunctions(classNode,
"Protected Functions",
QString(),
"protected function",
"protected functions");
- FastSection protectedSlots(classe,
+ FastSection protectedSlots(classNode,
"Protected Slots",
QString(),
"protected slot",
"protected slots");
- FastSection protectedTypes(classe,
+ FastSection protectedTypes(classNode,
"Protected Types",
QString(),
"protected type",
"protected types");
- FastSection protectedVariables(classe,
+ FastSection protectedVariables(classNode,
"Protected Variables",
QString(),
"protected type",
"protected variables");
- FastSection publicFunctions(classe,
+ FastSection publicFunctions(classNode,
"Public Functions",
QString(),
"public function",
"public functions");
- FastSection publicSignals(classe, "Signals", QString(), "signal", "signal");
- FastSection publicSlots(classe, "Public Slots", QString(), "public slot", "public slots");
- FastSection publicTypes(classe, "Public Types", QString(), "public type", "public types");
- FastSection publicVariables(classe,
+ FastSection publicSignals(classNode, "Signals", QString(), "signal", "signal");
+ FastSection publicSlots(classNode, "Public Slots", QString(), "public slot", "public slots");
+ FastSection publicTypes(classNode, "Public Types", QString(), "public type", "public types");
+ FastSection publicVariables(classNode,
"Public Variables",
QString(),
"public variable",
"public variables");
- FastSection properties(classe, "Properties", QString(), "property", "properties");
- FastSection relatedNonMembers(classe,
+ FastSection properties(classNode, "Properties", QString(), "property", "properties");
+ FastSection relatedNonMembers(classNode,
"Related Non-Members",
QString(),
"related non-member",
"related non-members");
- FastSection staticPrivateMembers(classe,
+ FastSection staticPrivateMembers(classNode,
"Static Private Members",
QString(),
"static private member",
"static private members");
- FastSection staticProtectedMembers(classe,
+ FastSection staticProtectedMembers(classNode,
"Static Protected Members",
QString(),
"static protected member",
"static protected members");
- FastSection staticPublicMembers(classe,
+ FastSection staticPublicMembers(classNode,
"Static Public Members",
QString(),
"static public member",
"static public members");
FastSection macros(inner, "Macros", QString(), "macro", "macros");
- NodeList::ConstIterator r = classe->relatedNodes().constBegin();
- while (r != classe->relatedNodes().constEnd()) {
+ NodeList::ConstIterator r = classNode->relatedNodes().constBegin();
+ while (r != classNode->relatedNodes().constEnd()) {
if ((*r)->type() == Node::Function) {
FunctionNode *func = static_cast<FunctionNode *>(*r);
if (func->isMacro())
@@ -531,7 +531,7 @@ QList<Section> CppCodeMarker::sections(const InnerNode *inner,
}
QStack<const ClassNode *> stack;
- stack.push(classe);
+ stack.push(classNode);
while (!stack.isEmpty()) {
const ClassNode *ancestorClass = stack.pop();
@@ -566,8 +566,7 @@ QList<Section> CppCodeMarker::sections(const InnerNode *inner,
insert(publicSignals, *c, style, status);
}
else if (isStatic) {
- if ((*c)->type() != Node::Variable
- || !(*c)->doc().isEmpty())
+ if ((*c)->type() != Node::Variable || !(*c)->doc().isEmpty())
insert(staticPublicMembers,*c,style,status);
}
else if ((*c)->type() == Node::Property) {
@@ -578,8 +577,9 @@ QList<Section> CppCodeMarker::sections(const InnerNode *inner,
insert(publicVariables, *c, style, status);
}
else if ((*c)->type() == Node::Function) {
- if (!insertReimpFunc(publicFunctions,*c,status))
+ if (!insertReimpFunc(publicFunctions,*c,status)) {
insert(publicFunctions, *c, style, status);
+ }
}
else {
insert(publicTypes, *c, style, status);
@@ -590,8 +590,7 @@ QList<Section> CppCodeMarker::sections(const InnerNode *inner,
insert(protectedSlots, *c, style, status);
}
else if (isStatic) {
- if ((*c)->type() != Node::Variable
- || !(*c)->doc().isEmpty())
+ if ((*c)->type() != Node::Variable || !(*c)->doc().isEmpty())
insert(staticProtectedMembers,*c,style,status);
}
else if ((*c)->type() == Node::Variable) {
@@ -599,8 +598,9 @@ QList<Section> CppCodeMarker::sections(const InnerNode *inner,
insert(protectedVariables,*c,style,status);
}
else if ((*c)->type() == Node::Function) {
- if (!insertReimpFunc(protectedFunctions,*c,status))
+ if (!insertReimpFunc(protectedFunctions,*c,status)) {
insert(protectedFunctions, *c, style, status);
+ }
}
else {
insert(protectedTypes, *c, style, status);
@@ -611,13 +611,13 @@ QList<Section> CppCodeMarker::sections(const InnerNode *inner,
insert(privateSlots, *c, style, status);
}
else if (isStatic) {
- if ((*c)->type() != Node::Variable
- || !(*c)->doc().isEmpty())
+ if ((*c)->type() != Node::Variable || !(*c)->doc().isEmpty())
insert(staticPrivateMembers,*c,style,status);
}
else if ((*c)->type() == Node::Function) {
- if (!insertReimpFunc(privateFunctions,*c,status))
+ if (!insertReimpFunc(privateFunctions,*c,status)) {
insert(privateFunctions, *c, style, status);
+ }
}
else {
insert(privateTypes,*c,style,status);
@@ -654,15 +654,15 @@ QList<Section> CppCodeMarker::sections(const InnerNode *inner,
append(sections, macros);
}
else if (style == Detailed) {
- FastSection memberFunctions(classe,"Member Function Documentation","func","member","members");
- FastSection memberTypes(classe,"Member Type Documentation","types","member","members");
- FastSection memberVariables(classe,"Member Variable Documentation","vars","member","members");
- FastSection properties(classe,"Property Documentation","prop","member","members");
- FastSection relatedNonMembers(classe,"Related Non-Members","relnonmem","member","members");
- FastSection macros(classe,"Macro Documentation","macros","member","members");
-
- NodeList::ConstIterator r = classe->relatedNodes().constBegin();
- while (r != classe->relatedNodes().constEnd()) {
+ FastSection memberFunctions(classNode,"Member Function Documentation","func","member","members");
+ FastSection memberTypes(classNode,"Member Type Documentation","types","member","members");
+ FastSection memberVariables(classNode,"Member Variable Documentation","vars","member","members");
+ FastSection properties(classNode,"Property Documentation","prop","member","members");
+ FastSection relatedNonMembers(classNode,"Related Non-Members","relnonmem","member","members");
+ FastSection macros(classNode,"Macro Documentation","macros","member","members");
+
+ NodeList::ConstIterator r = classNode->relatedNodes().constBegin();
+ while (r != classNode->relatedNodes().constEnd()) {
if ((*r)->type() == Node::Function) {
FunctionNode *func = static_cast<FunctionNode *>(*r);
if (func->isMacro())
@@ -676,8 +676,8 @@ QList<Section> CppCodeMarker::sections(const InnerNode *inner,
++r;
}
- NodeList::ConstIterator c = classe->childNodes().constBegin();
- while (c != classe->childNodes().constEnd()) {
+ NodeList::ConstIterator c = classNode->childNodes().constBegin();
+ while (c != classNode->childNodes().constEnd()) {
if ((*c)->type() == Node::Enum ||
(*c)->type() == Node::Typedef) {
insert(memberTypes, *c, style, status);
@@ -705,10 +705,10 @@ QList<Section> CppCodeMarker::sections(const InnerNode *inner,
append(sections, macros);
}
else {
- FastSection all(classe,QString(),QString(),"member","members");
+ FastSection all(classNode,QString(),QString(),"member","members");
QStack<const ClassNode *> stack;
- stack.push(classe);
+ stack.push(classNode);
while (!stack.isEmpty()) {
const ClassNode *ancestorClass = stack.pop();
diff --git a/src/tools/qdoc/tree.cpp b/src/tools/qdoc/tree.cpp
index c622fb929b..e7a8f5b5d0 100644
--- a/src/tools/qdoc/tree.cpp
+++ b/src/tools/qdoc/tree.cpp
@@ -398,6 +398,11 @@ void Tree::addPropertyFunction(PropertyNode* property,
}
/*!
+ This function resolves inheritance and reimplementation settings
+ for each class node found in the namspace beginning ar \a rootNode.
+ If it finds another namespace node in the child list of \a rootNode,
+ it calls itself recursively. For each child of \a rootNode that is a
+ class node, it calls the other resolveInheritance() function.
*/
void Tree::resolveInheritance(NamespaceNode* rootNode)
{
@@ -475,11 +480,24 @@ void Tree::resolveProperties()
}
/*!
+ This function is run twice for each \a classNode in the
+ tree. First it is run with \a pass set to 0 for each
+ \a classNode. Then it is run with \a pass set to 1 for
+ each \a classNode.
+
+ In \a pass 0, all the base classes of \a classNode are
+ found and added to the base class list for \a classNode.
+
+ In \a pass 1, each child of \a classNode that is a function
+ that is reimplemented from one of the base classes is marked
+ as being reimplemented from that class.
+
+ Some property node fixing up is also done in \a pass 1.
*/
-void Tree::resolveInheritance(int pass, ClassNode* classe)
+void Tree::resolveInheritance(int pass, ClassNode* classNode)
{
if (pass == 0) {
- QList<InheritanceBound> bounds = unresolvedInheritanceMap[classe];
+ QList<InheritanceBound> bounds = unresolvedInheritanceMap[classNode];
QList<InheritanceBound>::ConstIterator b = bounds.constBegin();
while (b != bounds.constEnd()) {
Node* n = findClassNode((*b).basePath);
@@ -487,17 +505,17 @@ void Tree::resolveInheritance(int pass, ClassNode* classe)
n = findClassNode((*b).basePath, (*b).parent);
}
if (n) {
- classe->addBaseClass((*b).access, static_cast<ClassNode*>(n), (*b).dataTypeWithTemplateArgs);
+ classNode->addBaseClass((*b).access, static_cast<ClassNode*>(n), (*b).dataTypeWithTemplateArgs);
}
++b;
}
}
else {
- NodeList::ConstIterator c = classe->childNodes().constBegin();
- while (c != classe->childNodes().constEnd()) {
+ NodeList::ConstIterator c = classNode->childNodes().constBegin();
+ while (c != classNode->childNodes().constEnd()) {
if ((*c)->type() == Node::Function) {
FunctionNode* func = (FunctionNode*)* c;
- FunctionNode* from = findVirtualFunctionInBaseClasses(classe, func);
+ FunctionNode* from = findVirtualFunctionInBaseClasses(classNode, func);
if (from != 0) {
if (func->virtualness() == FunctionNode::NonVirtual)
func->setVirtualness(FunctionNode::ImpureVirtual);
@@ -505,7 +523,7 @@ void Tree::resolveInheritance(int pass, ClassNode* classe)
}
}
else if ((*c)->type() == Node::Property) {
- fixPropertyUsingBaseClasses(classe, static_cast<PropertyNode*>(*c));
+ fixPropertyUsingBaseClasses(classNode, static_cast<PropertyNode*>(*c));
}
++c;
}
@@ -551,11 +569,11 @@ void Tree::fixInheritance(NamespaceNode* rootNode)
/*!
*/
-FunctionNode* Tree::findVirtualFunctionInBaseClasses(ClassNode* classe,
+FunctionNode* Tree::findVirtualFunctionInBaseClasses(ClassNode* classNode,
FunctionNode* clone)
{
- QList<RelatedClass>::ConstIterator r = classe->baseClasses().constBegin();
- while (r != classe->baseClasses().constEnd()) {
+ QList<RelatedClass>::ConstIterator r = classNode->baseClasses().constBegin();
+ while (r != classNode->baseClasses().constEnd()) {
FunctionNode* func;
if (((func = findVirtualFunctionInBaseClasses((*r).node, clone)) != 0 ||
(func = (*r).node->findFunctionNode(clone)) != 0)) {
@@ -569,10 +587,10 @@ FunctionNode* Tree::findVirtualFunctionInBaseClasses(ClassNode* classe,
/*!
*/
-void Tree::fixPropertyUsingBaseClasses(ClassNode* classe, PropertyNode* property)
+void Tree::fixPropertyUsingBaseClasses(ClassNode* classNode, PropertyNode* property)
{
- QList<RelatedClass>::const_iterator r = classe->baseClasses().constBegin();
- while (r != classe->baseClasses().constEnd()) {
+ QList<RelatedClass>::const_iterator r = classNode->baseClasses().constBegin();
+ while (r != classNode->baseClasses().constEnd()) {
Node* n = r->node->findChildNodeByNameAndType(property->name(), Node::Property);
if (n) {
PropertyNode* baseProperty = static_cast<PropertyNode*>(n);
@@ -588,10 +606,10 @@ void Tree::fixPropertyUsingBaseClasses(ClassNode* classe, PropertyNode* property
/*!
*/
-NodeList Tree::allBaseClasses(const ClassNode* classe) const
+NodeList Tree::allBaseClasses(const ClassNode* classNode) const
{
NodeList result;
- foreach (const RelatedClass& r, classe->baseClasses()) {
+ foreach (const RelatedClass& r, classNode->baseClasses()) {
result += r.node;
result += allBaseClasses(r.node);
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-30 14:10:39 +0000