Changeset 561 for trunk/tools/qdoc3/cppcodeparser.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/cppcodeparser.cpp (modified) (56 diffs)

trunk/tools/qdoc3/cppcodeparser.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$
 **
@@ -48 +48 @@
 
 #include <stdio.h>
+#include <errno.h>
 
 #include "codechunk.h"
@@ -88 +89 @@
 #define COMMAND_QMLCLASS                Doc::alias("qmlclass")
 #define COMMAND_QMLPROPERTY             Doc::alias("qmlproperty")
+#define COMMAND_QMLATTACHEDPROPERTY     Doc::alias("qmlattachedproperty")
+#define COMMAND_QMLINHERITS             Doc::alias("inherits")
+#define COMMAND_QMLSIGNAL               Doc::alias("qmlsignal")
+#define COMMAND_QMLATTACHEDSIGNAL       Doc::alias("qmlattachedsignal")
+#define COMMAND_QMLMETHOD               Doc::alias("qmlmethod")
+#define COMMAND_QMLATTACHEDMETHOD       Doc::alias("qmlattachedmethod")
+#define COMMAND_QMLDEFAULT              Doc::alias("default")
 #endif
 
@@ -110 +118 @@
             *link = arg.left(spaceAt).trimmed();
             *desc = arg.mid(spaceAt).trimmed();
-        } else {
+        }
+        else {
             *link = arg;
             *desc = arg;
@@ -189 +198 @@
 CppCodeParser::~CppCodeParser()
 {
-}
-
+    // nothing.
+}
+
+/*!
+  The constructor initializes a map of special node types
+  for identifying important nodes. And it initializes
+  some filters for identifying certain kinds of files.
+ */
 void CppCodeParser::initializeParser(const Config &config)
 {
@@ -203 +218 @@
     nodeTypeMap.insert(COMMAND_VARIABLE, Node::Variable);
 
-#ifdef QDOC_QML
-    //    nodeTypeMap.insert(COMMAND_QMLCLASS, Node::Class);
-    nodeTypeMap.insert(COMMAND_QMLPROPERTY, Node::Property);
-#endif    
-    
     exampleFiles = config.getStringList(CONFIG_EXAMPLES);
     exampleDirs = config.getStringList(CONFIG_EXAMPLEDIRS);
@@ -217 +227 @@
     else
         exampleNameFilter = "*.cpp *.h *.js *.xq *.svg *.xml *.ui";
-}
-
+
+    QStringList exampleImagePatterns = config.getStringList(
+        CONFIG_EXAMPLES + Config::dot + CONFIG_IMAGEEXTENSIONS);
+
+    if (!exampleImagePatterns.isEmpty())
+        exampleImageFilter = exampleImagePatterns.join(" ");
+    else
+        exampleImageFilter = "*.png";
+}
+
+/*!
+  Clear the map of common node types and call
+  the same function in the base class.
+ */
 void CppCodeParser::terminateParser()
 {
@@ -225 +247 @@
 }
 
+/*!
+  Returns "Cpp".
+ */
 QString CppCodeParser::language()
 {
@@ -230 +255 @@
 }
 
+/*!
+  Returns a list of extensions for header files.
+ */
 QString CppCodeParser::headerFileNameFilter()
 {
@@ -235 +263 @@
 }
 
+/*!
+  Returns a list of extensions for source files, i.e. not
+  header files.
+ */
 QString CppCodeParser::sourceFileNameFilter()
 {
@@ -282 +314 @@
     FILE *in = fopen(QFile::encodeName(filePath), "r");
     if (!in) {
-        location.error(tr("Cannot open C++ source file '%1'").arg(filePath));
+        location.error(tr("Cannot open C++ source file '%1' (%2)").arg(filePath).arg(strerror(errno)));
         return;
     }
@@ -296 +328 @@
 }
 
+/*!
+  This is called after all the header files have been parsed.
+  I think the most important thing it does is resolve class
+  inheritance links in the tree. But it also initializes a
+  bunch of stuff.
+ */
 void CppCodeParser::doneParsingHeaderFiles(Tree *tree)
 {
@@ -342 +380 @@
 }
 
+/*!
+  This is called after all the source files (i.e., not the
+  header files) have been parsed. It traverses the tree to
+  resolve property links, normalize overload signatures, and
+  do other housekeeping of the tree.
+ */
 void CppCodeParser::doneParsingSourceFiles(Tree *tree)
 {
@@ -350 +394 @@
 }
 
+/*!
+  This function searches the \a tree to find a FunctionNode
+  for a function with the signature \a synopsis. If the
+  \a relative node is provided, the search begins there. If
+  \a fuzzy is true, base classes are searched. The function
+  node is returned, if found.
+ */
 const FunctionNode *CppCodeParser::findFunctionNode(const QString& synopsis,
                                                     Tree *tree,
@@ -478 +529 @@
                            << COMMAND_SERVICE
                            << COMMAND_TYPEDEF
-#ifdef QDOC_QML        
+#ifdef QDOC_QML
                            << COMMAND_VARIABLE
                            << COMMAND_QMLCLASS
-                           << COMMAND_QMLPROPERTY;
-#else    
+                           << COMMAND_QMLPROPERTY
+                           << COMMAND_QMLATTACHEDPROPERTY
+                           << COMMAND_QMLSIGNAL
+                           << COMMAND_QMLATTACHEDSIGNAL
+                           << COMMAND_QMLMETHOD
+                           << COMMAND_QMLATTACHEDMETHOD;
+#else
                            << COMMAND_VARIABLE;
-#endif    
+#endif
 }
 
@@ -539 +595 @@
                 lastPath = parentPath;
             }
-
-            if (func)
+            if (func) {
                 func->borrowParameterNames(clone);
+                func->setParentPath(clone->parentPath());
+            }
             delete clone;
         }
@@ -588 +645 @@
          */
         // ### split(" ") hack is there to support header file syntax
-        QStringList paths = arg.split(" "); 
+        QStringList paths = arg.split(" ");
         QStringList path = paths[0].split("::");
-        
-#if QDOC2DOX        
-        // qdoc -> doxygen.
-        if (Doc::isDoxPass(1)) {
-            if (command == COMMAND_PROPERTY) {
-                Doc::insertProperty(path);
-            }
-            else if (command == COMMAND_VARIABLE) {
-                Doc::insertVariable(path);
-            }
-            else if (command == COMMAND_ENUM) {
-                // zzz
-            }
-        }
-#endif
-
         Node *node = 0;
         if (!usedNamespaces.isEmpty()) {
@@ -644 +685 @@
         }
 
+        if (command == COMMAND_CLASS) {
+            if (paths.size() > 1) {
+                if (!paths[1].endsWith(".h")) {
+                    ClassNode*cnode = static_cast<ClassNode*>(node);
+                    cnode->setQmlElement(paths[1]);
+                }
+            }
+        }
         return node;
     }
     else if (command == COMMAND_EXAMPLE) {
-        FakeNode *fake = new FakeNode(tre->root(), arg, FakeNode::Example);
+        FakeNode *fake = new FakeNode(tre->root(), arg, Node::Example);
         createExampleFileNodes(fake);
         return fake;
     }
     else if (command == COMMAND_EXTERNALPAGE) {
-        return new FakeNode(tre->root(), arg, FakeNode::ExternalPage);
+        return new FakeNode(tre->root(), arg, Node::ExternalPage);
     }
     else if (command == COMMAND_FILE) {
-        return new FakeNode(tre->root(), arg, FakeNode::File);
+        return new FakeNode(tre->root(), arg, Node::File);
     }
     else if (command == COMMAND_GROUP) {
-        return new FakeNode(tre->root(), arg, FakeNode::Group);
+        return new FakeNode(tre->root(), arg, Node::Group);
     }
     else if (command == COMMAND_HEADERFILE) {
-        return new FakeNode(tre->root(), arg, FakeNode::HeaderFile);
+        return new FakeNode(tre->root(), arg, Node::HeaderFile);
     }
     else if (command == COMMAND_MODULE) {
-        return new FakeNode(tre->root(), arg, FakeNode::Module);
+        return new FakeNode(tre->root(), arg, Node::Module);
     }
     else if (command == COMMAND_PAGE) {
-        return new FakeNode(tre->root(), arg, FakeNode::Page);
-    }
-#ifdef QDOC_QML    
+        return new FakeNode(tre->root(), arg, Node::Page);
+    }
+#ifdef QDOC_QML
     else if (command == COMMAND_QMLCLASS) {
         const ClassNode* classNode = 0;
-        QStringList names = arg.split(" "); 
-        //qDebug() << "QMLCLASS" << names;
+        QStringList names = arg.split(" ");
         if (names.size() > 1) {
             Node* n = tre->findNode(names[1].split("::"),Node::Class);
-            if (n) {
+            if (n)
                 classNode = static_cast<const ClassNode*>(n);
-                //qDebug() << "FOUND IT!" << classNode->name();
-            }
-        }
-        return new QmlNode(tre->root(), names[0], classNode);
-    }
-#endif    
+        }
+        return new QmlClassNode(tre->root(), names[0], classNode);
+    }
+    else if ((command == COMMAND_QMLSIGNAL) ||
+             (command == COMMAND_QMLMETHOD) ||
+             (command == COMMAND_QMLATTACHEDSIGNAL) ||
+             (command == COMMAND_QMLATTACHEDMETHOD)) {
+        QString element;
+        QString type;
+        QmlClassNode* qmlClass = 0;
+        if (splitQmlMethodArg(doc,arg,type,element)) {
+            Node* n = tre->findNode(QStringList(element),Node::Fake);
+            if (n && n->subType() == Node::QmlClass) {
+                qmlClass = static_cast<QmlClassNode*>(n);
+                if (command == COMMAND_QMLSIGNAL)
+                    return makeFunctionNode(doc,arg,qmlClass,Node::QmlSignal,false,COMMAND_QMLSIGNAL);
+                else if (command == COMMAND_QMLATTACHEDSIGNAL)
+                    return makeFunctionNode(doc,arg,qmlClass,Node::QmlSignal,true,COMMAND_QMLATTACHEDSIGNAL);
+                else if (command == COMMAND_QMLMETHOD)
+                    return makeFunctionNode(doc,arg,qmlClass,Node::QmlMethod,false,COMMAND_QMLMETHOD);
+                else if (command == COMMAND_QMLATTACHEDMETHOD)
+                    return makeFunctionNode(doc,arg,qmlClass,Node::QmlMethod,true,COMMAND_QMLATTACHEDMETHOD);
+                else
+                    return 0; // never get here.
+            }
+        }
+    }
+#endif
     return 0;
 }
+
+#ifdef QDOC_QML
+
+/*!
+  A QML property argument has the form...
+
+  <type> <element>::<name>
+
+  This function splits the argument into those three
+  parts, sets \a type, \a element, and \a name,
+  and returns true. If any of the parts isn't found,
+  a qdoc warning is output and false is returned.
+ */
+bool CppCodeParser::splitQmlPropertyArg(const Doc& doc,
+                                        const QString& arg,
+                                        QString& type,
+                                        QString& element,
+                                        QString& name)
+{
+    QStringList blankSplit = arg.split(" ");
+    if (blankSplit.size() > 1) {
+        type = blankSplit[0];
+        QStringList colonSplit(blankSplit[1].split("::"));
+        if (colonSplit.size() > 1) {
+            element = colonSplit[0];
+            name = colonSplit[1];
+            return true;
+        }
+        else
+            doc.location().warning(tr("Missing parent QML element name"));
+    }
+    else
+        doc.location().warning(tr("Missing property type"));
+    return false;
+}
+
+/*!
+  A QML signal or method argument has the form...
+
+  <type> <element>::<name>(<param>, <param>, ...)
+
+  This function splits the argument into those two
+  parts, sets \a element, and \a name, and returns
+  true. If either of the parts isn't found, a debug
+  message is output and false is returned.
+ */
+bool CppCodeParser::splitQmlMethodArg(const Doc& doc,
+                                      const QString& arg,
+                                      QString& type,
+                                      QString& element)
+{
+    QStringList colonSplit(arg.split("::"));
+    if (colonSplit.size() > 1) {
+        QStringList blankSplit = colonSplit[0].split(" ");
+        if (blankSplit.size() > 1) {
+            type = blankSplit[0];
+            element = blankSplit[1];
+        }
+        else {
+            type = QString("");
+            element = colonSplit[0];
+        }
+        return true;
+    }
+    else
+        doc.location().warning(tr("Missing parent QML element or method signature"));
+    return false;
+}
+
+/*!
+  Process the topic \a command group with arguments \a args.
+
+  Currently, this function is called only for \e{qmlproperty}
+  and \e{qmlattachedproperty}.
+ */
+Node *CppCodeParser::processTopicCommandGroup(const Doc& doc,
+                                              const QString& command,
+                                              const QStringList& args)
+{
+    QmlPropGroupNode* qmlPropGroup = 0;
+    if ((command == COMMAND_QMLPROPERTY) ||
+        (command == COMMAND_QMLATTACHEDPROPERTY)) {
+        QString type;
+        QString element;
+        QString property;
+        bool attached = (command == COMMAND_QMLATTACHEDPROPERTY);
+        QStringList::ConstIterator arg = args.begin();
+        if (splitQmlPropertyArg(doc,(*arg),type,element,property)) {
+            Node* n = tre->findNode(QStringList(element),Node::Fake);
+            if (n && n->subType() == Node::QmlClass) {
+                QmlClassNode* qmlClass = static_cast<QmlClassNode*>(n);
+                if (qmlClass)
+                    qmlPropGroup = new QmlPropGroupNode(qmlClass,
+                                                        property,
+                                                        attached);
+            }
+        }
+        if (qmlPropGroup) {
+            const ClassNode *correspondingClass = static_cast<const QmlClassNode*>(qmlPropGroup->parent())->classNode();
+            PropertyNode *correspondingProperty = 0;
+            if (correspondingClass)
+                correspondingProperty = static_cast<PropertyNode*>((Node*)correspondingClass->findNode(property, Node::Property));
+            QmlPropertyNode *qmlPropNode = new QmlPropertyNode(qmlPropGroup,property,type,attached);
+            if (correspondingProperty) {
+                bool writableList = type.startsWith("list") && correspondingProperty->dataType().endsWith('*');
+                qmlPropNode->setWritable(writableList || correspondingProperty->isWritable());
+            }
+            ++arg;
+            while (arg != args.end()) {
+                if (splitQmlPropertyArg(doc,(*arg),type,element,property)) {
+                    QmlPropertyNode* qmlPropNode = new QmlPropertyNode(qmlPropGroup,
+                                                                       property,
+                                                                       type,
+                                                                       attached);
+                    if (correspondingProperty) {
+                        bool writableList = type.startsWith("list") && correspondingProperty->dataType().endsWith('*');
+                        qmlPropNode->setWritable(writableList || correspondingProperty->isWritable());
+                    }
+                }
+                ++arg;
+            }
+        }
+    }
+    return qmlPropGroup;
+}
+#endif
 
 /*!
@@ -701 +897 @@
                                 << COMMAND_PREVIOUSPAGE
                                 << COMMAND_INDEXPAGE
+#ifdef QDOC_QML        
+                                << COMMAND_STARTPAGE
+                                << COMMAND_QMLINHERITS
+                                << COMMAND_QMLDEFAULT;
+#else    
                                 << COMMAND_STARTPAGE;
+#endif    
 }
 
@@ -743 +945 @@
                        "with the same signature or it exists but isn't virtual."));
             }
-#if 0 // Ideally, we would enable this check to warn whenever \reimp is used
-      // incorrectly, and only make the node internal if the function is a
-      // reimplementation of another function in a base class.
+            /*
+              Ideally, we would enable this check to warn whenever
+              \reimp is used incorrectly, and only make the node
+              internal if the function is a reimplementation of
+              another function in a base class.
+            */
             else if (from->access() == Node::Private
                      || from->parent()->access() == Node::Private) {
-                doc.location().warning(
-                    tr("Base function for '\\%1' in %2() is private or internal")
+                doc.location().warning(tr("'\\%1' in %2() should be '\\internal' because its base function is private or internal")
                     .arg(COMMAND_REIMP).arg(node->name()));
             }
-#endif
-            // Note: Setting the access to Private hides the documentation,
-            // but setting the status to Internal makes the node available
-            // in the XML output when the WebXMLGenerator is used.
+
+#if 0
+            // Reimplemented functions now reported in separate sections.
+            /*
+              Note: Setting the access to Private hides the documentation,
+              but setting the status to Internal makes the node available
+              in the XML output when the WebXMLGenerator is used.
+            */
             func->setAccess(Node::Private);
             func->setStatus(Node::Internal);
+#endif
+            func->setReimp(true);
         }
         else {
@@ -768 +978 @@
         InnerNode *pseudoParent;
         if (arg.startsWith("<") || arg.startsWith("\"")) {
-            pseudoParent = static_cast<InnerNode *>(tre->findNode(QStringList(arg), Node::Fake));
+            pseudoParent =
+                static_cast<InnerNode *>(tre->findNode(QStringList(arg),
+                                                       Node::Fake));
         }
         else {
             QStringList newPath = arg.split("::");
-            pseudoParent = static_cast<InnerNode *>(tre->findNode(QStringList(newPath), Node::Class));
+            pseudoParent =
+                static_cast<InnerNode*>(tre->findNode(QStringList(newPath),
+                                                      Node::Class));
             if (!pseudoParent)
-                pseudoParent = static_cast<InnerNode *>(tre->findNode(QStringList(newPath),
-                                                        Node::Namespace));
+                pseudoParent =
+                    static_cast<InnerNode*>(tre->findNode(QStringList(newPath),
+                                                          Node::Namespace));
         }
         if (!pseudoParent) {
@@ -800 +1015 @@
         setLink(node, Node::StartLink, arg);
     }
+#ifdef QDOC_QML
+    else if (command == COMMAND_QMLINHERITS) {
+        setLink(node, Node::InheritsLink, arg);
+    }
+    else if (command == COMMAND_QMLDEFAULT) {
+        QmlPropGroupNode* qpgn = static_cast<QmlPropGroupNode*>(node);
+        qpgn->setDefault();
+    }
+#endif
     else {
         processCommonMetaCommand(doc.location(),command,arg,node,tre);
@@ -879 +1103 @@
         return true;
     }
-    else {
+    else
         return false;
-    }
 }
 
@@ -916 +1139 @@
             if (tok == Tok_LeftAngle) {
                 leftAngleDepth++;
-            } else if (tok == Tok_RightAngle) {
+            }
+            else if (tok == Tok_RightAngle) {
                 leftAngleDepth--;
-            } else if (tok == Tok_LeftParen || tok == Tok_LeftBrace) {
+            }
+            else if (tok == Tok_LeftParen || tok == Tok_LeftBrace) {
                 ++parenAndBraceDepth;
-            } else if (tok == Tok_RightParen || tok == Tok_RightBrace) {
+            }
+            else if (tok == Tok_RightParen || tok == Tok_RightBrace) {
                 if (--parenAndBraceDepth < 0)
                     return false;
@@ -983 +1209 @@
             else
                 return false;
-        } else if (match(Tok_int) || match(Tok_char) || match(Tok_double)) {
+        }
+        else if (match(Tok_int) || match(Tok_char) || match(Tok_double)) {
             dataType->append(previousLexeme());
         }
@@ -1083 +1310 @@
         }
     }
-    func->addParameter(Parameter(dataType.toString(), "", name,
-                                  defaultValue.toString())); // ###
+    func->addParameter(Parameter(dataType.toString(),
+                                 "",
+                                 name,
+                                 defaultValue.toString())); // ###
     return true;
 }
@@ -1091 +1320 @@
                                       QStringList *parentPathPtr,
                                       FunctionNode **funcPtr,
-                                      const QString &templateStuff)
+                                      const QString &templateStuff,
+                                      Node::Type type,
+                                      bool attached)
 {
     CodeChunk returnType;
@@ -1121 +1352 @@
                 && (match(Tok_Q_DECLARE_FLAGS) || match(Tok_Q_PROPERTY)))
             returnType = CodeChunk(previousLexeme());
-        else
+        else {
             return false;
+        }
     }
 
@@ -1132 +1364 @@
 
     if (tok == Tok_operator &&
-         (returnType.toString().isEmpty() || returnType.toString().endsWith("::"))) {
+         (returnType.toString().isEmpty() ||
+          returnType.toString().endsWith("::"))) {
         // 'QString::operator const char *()'
         parentPath = returnType.toString().split(sep);
@@ -1151 +1384 @@
             }
         }
-        if (tok != Tok_LeftParen)
+        if (tok != Tok_LeftParen) {
             return false;
+        }
     }
     else if (tok == Tok_LeftParen) {
@@ -1168 +1402 @@
             matchTemplateAngles();
 
-            if (match(Tok_Gulbrandsen)) {
+            if (match(Tok_Gulbrandsen))
                 parentPath.append(name);
-            } else {
+            else
                 break;
-            }
         }
 
@@ -1185 +1418 @@
             }
         }
-        if (parent && (tok == Tok_Semicolon || tok == Tok_LeftBracket || tok == Tok_Colon)
+        if (parent && (tok == Tok_Semicolon ||
+                       tok == Tok_LeftBracket ||
+                       tok == Tok_Colon)
                 && access != Node::Private) {
             if (tok == Tok_LeftBracket) {
@@ -1197 +1432 @@
                     readToken();
                 }
-                if (tok != Tok_Semicolon)
+                if (tok != Tok_Semicolon) {
                     return false;
-            } else if (tok == Tok_Colon) {
+                }
+            }
+            else if (tok == Tok_Colon) {
                 returnType.appendHotspot();
 
@@ -1206 +1443 @@
                     readToken();
                 }
-                if (tok != Tok_Semicolon)
+                if (tok != Tok_Semicolon) {
                     return false;
+                }
             }
 
@@ -1220 +1458 @@
             return false;
         }
-        if (tok != Tok_LeftParen)
+        if (tok != Tok_LeftParen) {
             return false;
+        }
     }
     readToken();
 
-    FunctionNode *func = new FunctionNode(parent, name);
+    FunctionNode *func = new FunctionNode(type, parent, name, attached);
     func->setAccess(access);
     func->setLocation(location());
     func->setReturnType(returnType.toString());
+    func->setParentPath(parentPath);
     func->setTemplateStuff(templateStuff);
     if (compat)
@@ -1245 +1485 @@
     if (tok != Tok_RightParen) {
         do {
-            if (!matchParameter(func))
+            if (!matchParameter(func)) {
                 return false;
+            }
         } while (match(Tok_Comma));
     }
-    if (!match(Tok_RightParen))
+    if (!match(Tok_RightParen)) {
         return false;
+    }
 
     func->setConst(match(Tok_const));
@@ -1266 +1508 @@
         int braceDepth0 = tokenizer->braceDepth();
 
-        if (!match(Tok_LeftBrace))
+        if (!match(Tok_LeftBrace)) {
             return false;
+        }
         while (tokenizer->braceDepth() >= braceDepth0 && tok != Tok_Eoi)
             readToken();
@@ -1391 +1634 @@
     NamespaceNode *namespasse = 0;
     if (parent)
-        namespasse = static_cast<NamespaceNode *>(parent->findNode(namespaceName, Node::Namespace));
+        namespasse = static_cast<NamespaceNode*>(parent->findNode(namespaceName, Node::Namespace));
     if (!namespasse) {
         namespasse = new NamespaceNode(parent, namespaceName);
@@ -1457 +1700 @@
             if (enume->items().isEmpty()) {
                 strVal = "0";
-            } else {
+            }
+            else {
                 QString last = enume->items().last().value();
                 bool ok;
@@ -1467 +1711 @@
                         else
                             strVal = "0" + QString::number(n + 1, 8);
-                    } else {
+                    }
+                    else
                         strVal = QString::number(n + 1);
-                    }
                 }
             }
@@ -1475 +1719 @@
 
         enume->addItem(EnumItem(name, strVal));
-    } else {
+    }
+    else {
         VariableNode *var = new VariableNode(parent, name);
         var->setAccess(access);
@@ -1563 +1808 @@
         if (match(Tok_Ident)) {
             value = previousLexeme();
-        } else if (match(Tok_LeftParen)) {
+        }
+        else if (match(Tok_LeftParen)) {
             int depth = 1;
             while (tok != Tok_Eoi) {
@@ -1582 +1828 @@
         if (key == "READ")
             tre->addPropertyFunction(property, value, PropertyNode::Getter);
-        else if (key == "WRITE")
+        else if (key == "WRITE") {
             tre->addPropertyFunction(property, value, PropertyNode::Setter);
-        else if (key == "STORED")
+            property->setWritable(true);
+        } else if (key == "STORED")
             property->setStored(value.toLower() == "true");
         else if (key == "DESIGNABLE")
@@ -1590 +1837 @@
         else if (key == "RESET")
             tre->addPropertyFunction(property, value, PropertyNode::Resetter);
+        else if (key == "NOTIFY") {
+            tre->addPropertyFunction(property, value, PropertyNode::Notifier);
+        }
+
     }
     match(Tok_RightParen);
@@ -1754 +2005 @@
 
             Doc::trimCStyleComment(start_loc,comment);
-            /*
-              qdoc --> doxygen
-              We must also remember the location of the end
-              of the comment, so we can construct a diff for
-              it.
-            */
             Location end_loc(location());
 
@@ -1822 +2067 @@
                   There is a topic command. Process it.
                  */
+#ifdef QDOC_QML
+                if ((topic == COMMAND_QMLPROPERTY) ||
+                    (topic == COMMAND_QMLATTACHEDPROPERTY)) {
+                    Doc nodeDoc = doc;
+                    Node *node = processTopicCommandGroup(nodeDoc,topic,args);
+                    if (node != 0) {
+                        nodes.append(node);
+                        docs.append(nodeDoc);
+                    }
+                }
+                else {
+                    QStringList::ConstIterator a = args.begin();
+                    while (a != args.end()) {
+                        Doc nodeDoc = doc;
+                        Node *node = processTopicCommand(nodeDoc,topic,*a);
+                        if (node != 0) {
+                            nodes.append(node);
+                            docs.append(nodeDoc);
+                        }
+                        ++a;
+                    }
+                }
+#else
                 QStringList::ConstIterator a = args.begin();
                 while (a != args.end()) {
@@ -1832 +2100 @@
                     ++a;
                 }
+#endif                
             }
 
@@ -1839 +2108 @@
                 processOtherMetaCommands(*d, *n);
                 (*n)->setDoc(*d);
-                if ((*n)->isInnerNode() && ((InnerNode *)*n)->includes().isEmpty()) {
+                if ((*n)->isInnerNode() &&
+                    ((InnerNode *)*n)->includes().isEmpty()) {
                     InnerNode *m = static_cast<InnerNode *>(*n);
                     while (m->parent() != tre->root())
@@ -1887 +2157 @@
                                      QStringList *parentPathPtr,
                                      FunctionNode **funcPtr,
-                                     InnerNode *root)
+                                     InnerNode *root,
+                                     Node::Type type,
+                                     bool attached)
 {
     Tokenizer *outerTokenizer = tokenizer;
@@ -1899 +2171 @@
     readToken();
 
-    bool ok = matchFunctionDecl(root, parentPathPtr, funcPtr);
+    bool ok = matchFunctionDecl(root, parentPathPtr, funcPtr, QString(), type, attached);
     // potential memory leak with funcPtr
 
     tokenizer = outerTokenizer;
     tok = outerTok;
-
     return ok;
+}
+
+/*!
+  Create a new FunctionNode for a QML method or signal, as
+  specified by \a type, as a child of \a parent. \a sig is
+  the complete signature, and if \a attached is true, the
+  method or signal is "attached". \a qdoctag is the text of
+  the \a type.
+ */
+FunctionNode* CppCodeParser::makeFunctionNode(const Doc& doc,
+                                              const QString& sig,
+                                              InnerNode* parent,
+                                              Node::Type type,
+                                              bool attached,
+                                              QString qdoctag)
+{
+    QStringList pp;
+    FunctionNode* fn = 0;
+    if (!makeFunctionNode(sig,&pp,&fn,parent,type,attached) &&
+        !makeFunctionNode("void "+sig,&pp,&fn,parent,type,attached)) {
+        doc.location().warning(tr("Invalid syntax in '\\%1'").arg(qdoctag));
+    }
+    if (fn)
+        return fn;
+    return 0;
 }
 
@@ -1927 +2223 @@
         associativeIteratorDefinition = lines[2];
         mutableAssociativeIteratorDefinition = lines[3];
-    } else {
+    }
+    else {
         location.warning(tr("The qiterator.h hack failed"));
     }
@@ -1963 +2260 @@
                                         proFileName,
                                         userFriendlyFilePath);
+    
     if (fullPath.isEmpty()) {
         QString tmp = proFileName;
@@ -1982 +2280 @@
     fullPath.truncate(fullPath.lastIndexOf('/'));
 
-    QStringList exampleFiles = Config::getFilesHere(fullPath,
-                                                    exampleNameFilter);
+    QStringList exampleFiles = Config::getFilesHere(fullPath,exampleNameFilter);
+    QString imagesPath = fullPath + "/images";
+    QStringList imageFiles = Config::getFilesHere(imagesPath,exampleImageFilter);
+
+#if 0    
+    qDebug() << "examplePath:" << examplePath;
+    qDebug() << " exampleFiles" <<  exampleFiles;
+    qDebug() << "imagesPath:" << imagesPath;
+    qDebug() << "fullPath:" << fullPath;
+    qDebug() << " imageFiles" <<  imageFiles;
+#endif    
+
     if (!exampleFiles.isEmpty()) {
         // move main.cpp and to the end, if it exists
@@ -2009 +2317 @@
         (void) new FakeNode(fake,
                             exampleFile.mid(sizeOfBoringPartOfName),
-                            FakeNode::File);
+                            Node::File);
+    foreach (const QString &imageFile, imageFiles) {
+        new FakeNode(fake,
+                     imageFile.mid(sizeOfBoringPartOfName),
+                     Node::Image);
+    }
 }