FCL/sf/mw/qt: comparison tools/qdoc3/cppcodeparser.cpp

equal deleted inserted replaced

-:93b982ccede2
+:5daf16870df6
 /*
 cppcodeparser.cpp
 */
-#include <QtCore>
 #include <qfile.h>
 #include <stdio.h>
 #include <errno.h>
+#include <qdebug.h>
 #include "codechunk.h"
 #include "config.h"
 #include "cppcodeparser.h"
 #include "tokenizer.h"
 #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")
+#define COMMAND_QMLBASICTYPE            Doc::alias("qmlbasictype")
 #endif
 QStringList CppCodeParser::exampleFiles;
 QStringList CppCodeParser::exampleDirs;
 */
 void CppCodeParser::parseHeaderFile(const Location& location,
 const QString& filePath,
 Tree *tree)
 {
-FILE *in = fopen(QFile::encodeName(filePath), "r");
+QFile in(filePath);
-if (!in) {
+if (!in.open(QIODevice::ReadOnly)) {
 location.error(tr("Cannot open C++ header file '%1'").arg(filePath));
 return;
 }
 reset(tree);
 tokenizer = &fileTokenizer;
 readToken();
 matchDeclList(tree->root());
 if (!fileTokenizer.version().isEmpty())
 tree->setVersion(fileTokenizer.version());
-fclose(in);
+in.close();
 if (fileLocation.fileName() == "qiterator.h")
 parseQiteratorDotH(location, filePath);
 }
 */
 void CppCodeParser::parseSourceFile(const Location& location,
 const QString& filePath,
 Tree *tree)
 {
-FILE *in = fopen(QFile::encodeName(filePath), "r");
+QFile in(filePath);
-if (!in) {
+if (!in.open(QIODevice::ReadOnly)) {
 location.error(tr("Cannot open C++ source file '%1' (%2)").arg(filePath).arg(strerror(errno)));
 return;
 }
 reset(tree);
 Tokenizer fileTokenizer(fileLocation, in);
 tokenizer = &fileTokenizer;
 readToken();
 usedNamespaces.clear();
 matchDocsAndStuff();
-fclose(in);
+in.close();
 }
 /*!
 This is called after all the header files have been parsed.
 I think the most important thing it does is resolve class
 }
 if (j == params1.count())
 candidates << overload;
 }
 /*
 There are several functions with the correct
 parameter count, but only one has the correct
 types, loosely compared.
 */
 << COMMAND_QMLPROPERTY
 << COMMAND_QMLATTACHEDPROPERTY
 << COMMAND_QMLSIGNAL
 << COMMAND_QMLATTACHEDSIGNAL
 << COMMAND_QMLMETHOD
-<< COMMAND_QMLATTACHEDMETHOD;
+<< COMMAND_QMLATTACHEDMETHOD
+<< COMMAND_QMLBASICTYPE;
 #else
 << COMMAND_VARIABLE;
 #endif
 }
 /*!
 Process the topic \a command in context \a doc with argument \a arg.
 */
 Node *CppCodeParser::processTopicCommand(const Doc& doc,
 const QString& command,
 const QString& arg)
 {
 Node* n = tre->findNode(names[1].split("::"),Node::Class);
 if (n)
 classNode = static_cast<const ClassNode*>(n);
 }
 return new QmlClassNode(tre->root(), names[0], classNode);
+}
+else if (command == COMMAND_QMLBASICTYPE) {
+#if 0
+QStringList parts = arg.split(" ");
+qDebug() << command << parts;
+if (parts.size() > 1) {
+FakeNode* pageNode = static_cast<FakeNode*>(tre->root()->findNode(parts[1], Node::Fake));
+if (pageNode) {
+qDebug() << "FOUND";
+return new QmlBasicTypeNode(pageNode, parts[0]);
+}
+}
+#endif
+return new QmlBasicTypeNode(tre->root(), arg);
 }
 else if ((command == COMMAND_QMLSIGNAL) ||
 (command == COMMAND_QMLMETHOD) ||
 (command == COMMAND_QMLATTACHEDSIGNAL) ||
 (command == COMMAND_QMLATTACHEDMETHOD)) {
 << COMMAND_RELATES
 << COMMAND_CONTENTSPAGE
 << COMMAND_NEXTPAGE
 << COMMAND_PREVIOUSPAGE
 << COMMAND_INDEXPAGE
 #ifdef QDOC_QML
 << COMMAND_STARTPAGE
 << COMMAND_QMLINHERITS
 << COMMAND_QMLDEFAULT;
 #else
 << COMMAND_STARTPAGE;
 #endif
 }
 /*!
 Process the metacommand \a command in the context of the
 \a node associated with the topic command and the \a doc.
 setLink(node, Node::StartLink, arg);
 }
 #ifdef QDOC_QML
 else if (command == COMMAND_QMLINHERITS) {
 setLink(node, Node::InheritsLink, arg);
-}
+if (node->subType() == Node::QmlClass) {
+QmlClassNode::addInheritedBy(arg,node);
+}
+}
 else if (command == COMMAND_QMLDEFAULT) {
 QmlPropGroupNode* qpgn = static_cast<QmlPropGroupNode*>(node);
 qpgn->setDefault();
 }
 #endif
 /*
 So far, so good. We have 'namespace Foo {'.
 */
 QString namespaceName = previousLexeme();
 NamespaceNode *namespasse = 0;
-if (parent)
+if (parent) {
 namespasse = static_cast<NamespaceNode*>(parent->findNode(namespaceName, Node::Namespace));
+}
 if (!namespasse) {
 namespasse = new NamespaceNode(parent, namespaceName);
 namespasse->setAccess(access);
 namespasse->setLocation(location());
 }
 nodes.append(node);
 docs.append(nodeDoc);
 }
 ++a;
 }
 #endif
 }
 NodeList::Iterator n = nodes.begin();
 QList<Doc>::Iterator d = docs.begin();
 while (n != nodes.end()) {
 }
 void CppCodeParser::createExampleFileNodes(FakeNode *fake)
 {
 QString examplePath = fake->name();
+QString proFileName = examplePath + "/" + examplePath.split("/").last() + ".pro";
-// we can assume that this file always exists
-QString proFileName = examplePath + "/" +
-examplePath.split("/").last() + ".pro";
 QString userFriendlyFilePath;
 QString fullPath = Config::findFile(fake->doc().location(),
 exampleFiles,
 exampleDirs,
 proFileName,
 userFriendlyFilePath);
 if (fullPath.isEmpty()) {
 QString tmp = proFileName;
 proFileName = examplePath + "/" + "qbuild.pro";
 userFriendlyFilePath.clear();
 fullPath = Config::findFile(fake->doc().location(),
 exampleFiles,
 exampleDirs,
 proFileName,
 userFriendlyFilePath);
 if (fullPath.isEmpty()) {
-fake->doc().location().warning(
+proFileName = examplePath + "/" + examplePath.split("/").last() + ".qmlproject";
-tr("Cannot find file '%1' or '%2'").arg(tmp).arg(proFileName));
+userFriendlyFilePath.clear();
-return;
+fullPath = Config::findFile(fake->doc().location(),
+exampleFiles,
+exampleDirs,
+proFileName,
+userFriendlyFilePath);
+if (fullPath.isEmpty()) {
+fake->doc().location().warning(
+tr("Cannot find file '%1' or '%2'").arg(tmp).arg(proFileName));
+return;
+}
 }
 }
 int sizeOfBoringPartOfName = fullPath.size() - proFileName.size();
 fullPath.truncate(fullPath.lastIndexOf('/'));
 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
 QString mainCpp;
 QMutableStringListIterator i(exampleFiles);
 if (fileName.endsWith("/main.cpp")) {
 mainCpp = fileName;
 i.remove();
 }
 else if (fileName.contains("/qrc_") || fileName.contains("/moc_")
 || fileName.contains("/ui_"))
 i.remove();
 }
 if (!mainCpp.isEmpty())
 exampleFiles.append(mainCpp);
 // add any qmake Qt resource files and qmake project files
-exampleFiles += Config::getFilesHere(fullPath, "*.qrc *.pro");
+exampleFiles += Config::getFilesHere(fullPath, "*.qrc *.pro qmldir");
 }
 foreach (const QString &exampleFile, exampleFiles)
 (void) new FakeNode(fake,
 exampleFile.mid(sizeOfBoringPartOfName),

branch	GCC_SURGE
changeset 31	5daf16870df6
parent 30	5dc02b23752f
child 33	3e2da88830cd