Long live Qt!

1 files changed, 547 insertions, 0 deletions

diff --git a/tools/qdoc3/jambiapiparser.cpp b/tools/qdoc3/jambiapiparser.cpp
new file mode 100644
index 0000000..73d10a6
--- /dev/null
+++ b/tools/qdoc3/jambiapiparser.cpp
@@ -0,0 +1,547 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** 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.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*
+    jambiapiparser.cpp
+*/
+
+#include <QtXml>
+
+#include "cppcodeparser.h"
+#include "jambiapiparser.h"
+#include "node.h"
+#include "tree.h"
+
+QT_BEGIN_NAMESPACE
+
+static const char USED_INTERNALLY[] = "";
+
+static Text textWithFixedBrief(const Text &text, const Text &beforeBrief,
+                               const Text &afterBrief)
+{
+    Text result;
+
+    const Atom *atom = text.firstAtom();
+    while (atom) {
+        if (atom->type() == Atom::BriefLeft) {
+            result << Atom::ParaLeft << beforeBrief;
+        } else if (atom->type() == Atom::BriefRight) {
+            result << afterBrief << Atom::ParaRight;
+        } else {
+            result << *atom;
+        }
+        atom = atom->next();
+    }
+
+    return result;
+}
+
+static void setPass1JambifiedDoc(Node *javaNode, const Node *cppNode, const QString &qName = "")
+{
+    Doc newDoc(cppNode->doc());
+
+    if (javaNode->type() == Node::Function) {
+        const FunctionNode *javaFunc = static_cast<const FunctionNode *>(javaNode);
+        if (cppNode->type() == Node::Function) {
+            const FunctionNode *cppFunc = static_cast<const FunctionNode *>(cppNode);
+            if (const PropertyNode *property = cppFunc->associatedProperty()) {
+                newDoc = property->doc();
+                Text text(newDoc.body());
+
+                Node *mutableCppNode = const_cast<Node *>(cppNode);
+                if (property->getters().contains(mutableCppNode)) {
+                    text = textWithFixedBrief(text, Text("Returns "), Text("."));
+                } else if (property->setters().contains(mutableCppNode)) {
+                    Text afterBrief;
+                    if (javaFunc->parameterNames().count() == 1
+                            && !javaFunc->parameterNames().first().isEmpty()) {
+                        afterBrief << " to "
+                                   << Atom(Atom::FormattingLeft, ATOM_FORMATTING_PARAMETER)
+                                   << javaFunc->parameterNames().first()
+                                   << Atom(Atom::FormattingRight, ATOM_FORMATTING_PARAMETER);
+                    }
+                    afterBrief << ".";
+                    text = textWithFixedBrief(text, Text("Sets "), afterBrief);
+                } else if (property->resetters().contains(mutableCppNode)) {
+                    text = textWithFixedBrief(text, Text("Resets "), Text("."));
+                }
+
+                newDoc.setBody(text);
+            } else {
+                QStringList javaParams = javaFunc->parameterNames();
+                QStringList cppParams = cppFunc->parameterNames();
+                newDoc.renameParameters(cppParams, javaParams);
+
+                if (cppNode->access() == Node::Private) {
+                    Text text;
+                    text << Atom::ParaLeft;
+                    if (cppFunc->reimplementedFrom()) {
+                        text << "This function is reimplemented for internal reasons.";
+                    } else {
+                        text << USED_INTERNALLY;
+                    }
+                    text << Atom::ParaRight;
+                    newDoc.setBody(text);
+                }
+            }
+        } else if (cppNode->type() == Node::Variable) {
+            Text text(newDoc.body());
+
+            if (qName == "variablegetter") {
+                text = textWithFixedBrief(text, Text("Returns "), Text("."));
+            } else if (qName == "variablesetter") {
+                Text afterBrief;
+                if (javaFunc->parameterNames().count() == 1
+                        && !javaFunc->parameterNames().first().isEmpty()) {
+                    afterBrief << " to "
+                               << Atom(Atom::FormattingLeft, ATOM_FORMATTING_PARAMETER)
+                               << javaFunc->parameterNames().first()
+                               << Atom(Atom::FormattingRight, ATOM_FORMATTING_PARAMETER);
+                }
+                afterBrief << ".";
+                text = textWithFixedBrief(text, Text("Sets "), afterBrief);
+            }
+
+            newDoc.setBody(text);
+        }
+    } else {    // ### enum value names?
+
+    }
+
+    javaNode->setDoc(newDoc, true);
+}
+
+static void setStatus(Node *javaNode, const Node *cppNode)
+{
+    if (cppNode->status() == Node::Compat) {
+        javaNode->setStatus(Node::Obsolete);
+    } else {
+        javaNode->setStatus(cppNode->status());
+    }
+}
+
+static Text findEnumText(Node *javaEnum, const QString &enumItemName)
+{
+    const Text &body = javaEnum->doc().body();
+    const Atom *atom = body.firstAtom();
+    while (atom) {
+        if (atom->type() == Atom::ListTagLeft && atom->string() == ATOM_LIST_VALUE) {
+            atom = atom->next();
+            if (atom) {
+                // ### paras?
+                if (atom->string() == enumItemName)
+                    return body.subText(Atom::ListItemLeft, Atom::ListItemRight, atom);
+            }
+        } else {
+            atom = atom->next();
+        }
+    }
+    return Text();
+}
+
+JambiApiParser::JambiApiParser(Tree *cppTree)
+    : cppTre(cppTree), javaTre(0), metJapiTag(false)
+{
+}
+
+JambiApiParser::~JambiApiParser()
+{
+}
+
+void JambiApiParser::initializeParser(const Config &config)
+{
+    CodeParser::initializeParser(config);
+}
+
+void JambiApiParser::terminateParser()
+{
+    CodeParser::terminateParser();
+}
+
+QString JambiApiParser::language()
+{
+    return "Java";
+}
+
+QString JambiApiParser::sourceFileNameFilter()
+{
+    return "*.japi";
+}
+
+void JambiApiParser::parseSourceFile(const Location &location, const QString &filePath, Tree *tree)
+{
+    javaTre = tree;
+    metJapiTag = false;
+
+    QXmlSimpleReader reader;
+    reader.setContentHandler(this);
+    reader.setErrorHandler(this);
+
+    QFile file(filePath);
+    if (!file.open(QFile::ReadOnly)) {
+        location.warning(tr("Cannot open JAPI file '%1'").arg(filePath));
+        return;
+    }
+
+    japiLocation = Location(filePath);
+    QXmlInputSource xmlSource(&file);
+    reader.parse(xmlSource);
+}
+
+void JambiApiParser::doneParsingSourceFiles(Tree * /* tree */)
+{
+    /*
+        Also import the overview documents.
+    */
+    foreach (Node *cppNode, cppTre->root()->childNodes()) {
+        if (cppNode->type() == Node::Fake) {
+            FakeNode *cppFake = static_cast<FakeNode *>(cppNode);
+            if (cppFake->subType() == FakeNode::Page) {
+                FakeNode *javaFake = new FakeNode(javaTre->root(), cppFake->name(),
+                                                  cppFake->subType());
+                javaFake->setModuleName("com.trolltech.qt");    // ### hard-coded
+                javaFake->setTitle(cppFake->title());
+                javaFake->setSubTitle(cppFake->subTitle());
+                setStatus(javaFake, cppFake);
+                setPass1JambifiedDoc(javaFake, cppFake);
+            }
+        }
+    }
+
+    /*
+        Fix the docs.
+    */
+    if (javaTre) {
+        javaTre->resolveInheritance();
+        jambifyDocsPass2(javaTre->root());
+        javaTre = 0;
+    }
+}
+
+bool JambiApiParser::startElement(const QString & /* namespaceURI */,
+                                  const QString & /* localName */,
+                                  const QString &qName,
+                                  const QXmlAttributes &attributes)
+{
+    if (!metJapiTag && qName != "japi") {
+        // ### The file is not a JAPI file.
+        return true;
+    }
+    metJapiTag = true;
+
+    EnumNode *javaEnum = 0;
+    EnumNode *cppEnum = 0;
+    InnerNode *javaParent = javaTre->root();
+    InnerNode *cppParent = cppTre->root();
+
+    for (int i = 0; i < classAndEnumStack.count(); ++i) {
+        const ClassOrEnumInfo &info = classAndEnumStack.at(i);
+        if (info.cppNode) {
+            if (info.cppNode->type() == Node::Enum) {
+                Q_ASSERT(info.javaNode->type() == Node::Enum);
+                javaEnum = static_cast<EnumNode *>(info.javaNode);
+                cppEnum = static_cast<EnumNode *>(info.cppNode);
+            } else {
+                Q_ASSERT(info.javaNode->type() == Node::Class
+                         || info.javaNode->type() == Node::Namespace);
+                javaParent = static_cast<InnerNode *>(info.javaNode);
+                cppParent = static_cast<InnerNode *>(info.cppNode);
+            }
+        }
+    }
+
+    if (qName == "class" || qName == "enum") {
+        Node::Type type = (qName == "class") ? Node::Class : Node::Enum;
+
+        QString javaExtends = attributes.value("java-extends");
+        QString javaImplements = attributes.value("javaimplements");
+
+        ClassOrEnumInfo info;
+        info.tag = qName;
+        info.javaName = attributes.value("java");
+        info.cppName = attributes.value("cpp");
+        info.cppNode = cppTre->findNode(info.cppName.split("::"), type, cppParent);
+        if (!info.cppNode && type == Node::Class) {
+            type = Node::Namespace;
+            info.cppNode = cppTre->findNode(info.cppName.split("::"), type, cppParent);
+        }
+
+        if (!info.cppNode) {
+            japiLocation.warning(tr("Cannot find C++ class or enum '%1'").arg(info.cppName));
+        } else {
+            if (qName == "class") {
+                ClassNode *javaClass = new ClassNode(javaParent, info.javaName);
+                javaClass->setModuleName(attributes.value("package"));
+                if (!javaExtends.isEmpty())
+                    javaTre->addBaseClass(javaClass, Node::Public, javaExtends.split('.'),
+                                          javaExtends);
+                if (!javaImplements.isEmpty())
+                    javaTre->addBaseClass(javaClass, Node::Public, javaImplements.split('.'),
+                                          javaExtends);
+
+                info.javaNode = javaClass;
+            } else {
+                info.javaNode = new EnumNode(javaParent, info.javaName);
+            }
+            info.javaNode->setLocation(japiLocation);
+            setStatus(info.javaNode, info.cppNode);
+
+            setPass1JambifiedDoc(info.javaNode, info.cppNode);
+        }
+        classAndEnumStack.push(info);
+    } else if (qName == "method" || qName == "signal") {
+        QString javaSignature = attributes.value("java");
+        if (javaSignature.startsWith("private"))
+            return true;
+
+        QString cppSignature = attributes.value("cpp");
+
+        CppCodeParser cppParser;
+        const FunctionNode *cppNode = cppParser.findFunctionNode(cppSignature, cppTre,
+                                                                 cppParent,
+                                                                 true /* fuzzy */);
+        if (!cppNode) {
+            bool quiet = false;
+
+            /*
+                Default constructors sometimes don't exist in C++.
+            */
+            if (!quiet && javaSignature == "public " + javaParent->name() + "()")
+                quiet = true;
+
+            if (!quiet)
+                japiLocation.warning(tr("Cannot find C++ function '%1' ('%2')")
+                                     .arg(cppSignature).arg(cppParent->name()));
+        }
+
+        FunctionNode *javaNode;
+        if (makeFunctionNode(javaParent, javaSignature, &javaNode)) {
+            javaNode->setLocation(japiLocation);
+            if (qName == "signal")
+                javaNode->setMetaness(FunctionNode::Signal);
+
+            if (cppNode) {
+                setStatus(javaNode, cppNode);
+
+                int overloadNo = cppNode->parameters().count() - javaNode->parameters().count() + 1;
+                if (overloadNo == 1) {
+                    setPass1JambifiedDoc(javaNode, cppNode);
+                } else {
+                    Text text;
+
+                    text << Atom::ParaLeft << "Equivalent to "
+                         << Atom(Atom::Link, javaNode->name() + "()")
+                         << Atom(Atom::FormattingLeft, ATOM_FORMATTING_LINK)
+                         << javaNode->name()
+                         << Atom(Atom::FormattingRight, ATOM_FORMATTING_LINK)
+                         << "(";
+
+                    for (int i = 0; i < cppNode->parameters().count(); ++i) {
+                        if (i > 0)
+                            text << ", ";
+                        if (i < javaNode->parameters().count()) {
+                            text << Atom(Atom::FormattingLeft, ATOM_FORMATTING_PARAMETER)
+                                 << javaNode->parameters().at(i).name()
+                                 << Atom(Atom::FormattingRight, ATOM_FORMATTING_PARAMETER);
+                        } else {
+                            // ### convert to Java
+                            text << cppNode->parameters().at(i).defaultValue();
+                        }
+                    }
+
+                    text << ").";
+
+                    Doc doc;
+                    doc.setBody(text);
+                    javaNode->setDoc(doc, true);
+                }
+                javaNode->setOverload(overloadNo > 1);
+            }
+        }
+    } else if (qName == "variablesetter" || qName == "variablegetter") {
+        QString javaSignature = attributes.value("java");
+        if (javaSignature.startsWith("private"))
+            return true;
+
+        QString cppVariable = attributes.value("cpp");
+
+        VariableNode *cppNode = static_cast<VariableNode *>(cppParent->findNode(cppVariable,
+                                                                                Node::Variable));
+        FunctionNode *javaNode;
+        if (makeFunctionNode(javaParent, javaSignature, &javaNode)) {
+            javaNode->setLocation(japiLocation);
+
+            if (!cppNode) {
+#if 0
+                japiLocation.warning(tr("Cannot find C++ variable '%1' ('%2')")
+                                     .arg(cppVariable).arg(cppParent->name()));
+#endif
+                javaNode->setDoc(Doc(japiLocation, japiLocation,
+                                     USED_INTERNALLY,
+                                     QSet<QString>()), true);
+            } else {
+                setPass1JambifiedDoc(javaNode, cppNode, qName);
+                setStatus(javaNode, cppNode);
+            }
+        }
+    } else if (qName == "enum-value") {
+        QString javaName = attributes.value("java");
+        QString cppName = attributes.value("cpp");
+        QString value = attributes.value("value");
+
+        if (javaEnum) {
+            EnumItem item(javaName, value, findEnumText(javaEnum, javaName));
+            javaEnum->addItem(item);
+        }
+    }
+
+    return true;
+}
+
+bool JambiApiParser::endElement(const QString & /* namespaceURI */,
+                                const QString & /* localName */,
+                                const QString &qName)
+{
+    if (qName == "class" || qName == "enum")
+        classAndEnumStack.pop();
+    return true;
+}
+
+bool JambiApiParser::fatalError(const QXmlParseException &exception)
+{
+    japiLocation.setLineNo(exception.lineNumber());
+    japiLocation.setColumnNo(exception.columnNumber());
+    japiLocation.warning(tr("Syntax error in JAPI file (%1)").arg(exception.message()));
+    return true;
+}
+
+void JambiApiParser::jambifyDocsPass2(Node *node)
+{
+    const Doc &doc = node->doc();
+    if (!doc.isEmpty()) {
+        if (node->type() == Node::Enum) {
+            Doc newDoc(doc);
+            newDoc.simplifyEnumDoc();
+            node->setDoc(newDoc, true);
+        }
+    }
+
+    if (node->isInnerNode()) {
+        InnerNode *innerNode = static_cast<InnerNode *>(node);
+        foreach (Node *child, innerNode->childNodes())
+            jambifyDocsPass2(child);
+    }
+}
+
+bool JambiApiParser::makeFunctionNode(InnerNode *parent, const QString &synopsis,
+				      FunctionNode **funcPtr)
+{
+    Node::Access access = Node::Public;
+    FunctionNode::Metaness metaness = FunctionNode::Plain;
+    bool final = false;
+    bool statique = false;
+
+    QString mySynopsis = synopsis.simplified();
+    int oldLen;
+    do {
+        oldLen = mySynopsis.length();
+
+        if (mySynopsis.startsWith("public ")) {
+            mySynopsis.remove(0, 7);
+            access = Node::Public;
+        }
+        if (mySynopsis.startsWith("protected ")) {
+            mySynopsis.remove(0, 10);
+            access = Node::Protected;
+        }
+        if (mySynopsis.startsWith("private ")) {
+            mySynopsis.remove(0, 8);
+            access = Node::Private;
+        }
+        if (mySynopsis.startsWith("native ")) {
+            mySynopsis.remove(0, 7);
+            metaness = FunctionNode::Native;
+        }
+        if (mySynopsis.startsWith("final ")) {
+            mySynopsis.remove(0, 6);
+            final = true;
+        }
+        if (mySynopsis.startsWith("static ")) {
+            mySynopsis.remove(0, 7);
+            statique = true;
+        }
+    } while (oldLen != mySynopsis.length());
+
+    // method or constructor
+    QRegExp funcRegExp("(?:(.*) )?([A-Za-z_0-9]+)\\((.*)\\)");
+    if (!funcRegExp.exactMatch(mySynopsis))
+        return false;
+
+    QString retType = funcRegExp.cap(1);
+    QString funcName = funcRegExp.cap(2);
+    QStringList params = funcRegExp.cap(3).split(",");
+
+    FunctionNode *func = new FunctionNode(parent, funcName);
+    func->setReturnType(retType);
+    func->setAccess(access);
+    func->setStatic(statique);
+    func->setConst(final);
+    func->setMetaness(metaness);
+
+    QRegExp paramRegExp(" ?([^ ].*) ([A-Za-z_0-9]+) ?");
+
+    foreach (const QString &param, params) {
+        if (paramRegExp.exactMatch(param)) {
+            func->addParameter(Parameter(paramRegExp.cap(1), "", paramRegExp.cap(2)));
+        } else {
+            // problem
+        }
+    }
+
+    if (funcPtr) {
+        *funcPtr = func;
+    } else if (!parent) {
+        delete func;
+    }
+    return true;
+}
+
+QT_END_NAMESPACE