/****************************************************************************+
−
**+
−
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).+
−
** All rights reserved.+
−
** Contact: Nokia Corporation (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 Technology Preview License Agreement accompanying+
−
** this package.+
−
**+
−
** 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.1, included in the file LGPL_EXCEPTION.txt in this package.+
−
**+
−
** If you have questions regarding the use of this file, please contact+
−
** Nokia at qt-info@nokia.com.+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
** $QT_END_LICENSE$+
−
**+
−
****************************************************************************/+
−
+
−
/*+
−
  cppcodeparser.cpp+
−
*/+
−
+
−
#include <QtCore>+
−
#include <qfile.h>+
−
+
−
#include <stdio.h>+
−
#include <errno.h>+
−
+
−
#include "codechunk.h"+
−
#include "config.h"+
−
#include "cppcodeparser.h"+
−
#include "tokenizer.h"+
−
#include "tree.h"+
−
+
−
QT_BEGIN_NAMESPACE+
−
+
−
/* qmake ignore Q_OBJECT */+
−
+
−
#define COMMAND_CLASS                   Doc::alias("class")+
−
#define COMMAND_CONTENTSPAGE            Doc::alias("contentspage")+
−
#define COMMAND_ENUM                    Doc::alias("enum")+
−
#define COMMAND_EXAMPLE                 Doc::alias("example")+
−
#define COMMAND_EXTERNALPAGE            Doc::alias("externalpage")+
−
#define COMMAND_FILE                    Doc::alias("file") // ### don't document+
−
#define COMMAND_FN                      Doc::alias("fn")+
−
#define COMMAND_GROUP                   Doc::alias("group")+
−
#define COMMAND_HEADERFILE              Doc::alias("headerfile")+
−
#define COMMAND_INDEXPAGE               Doc::alias("indexpage")+
−
#define COMMAND_INHEADERFILE            Doc::alias("inheaderfile") // ### don't document+
−
#define COMMAND_MACRO                   Doc::alias("macro")+
−
#define COMMAND_MODULE                  Doc::alias("module") // ### don't document+
−
#define COMMAND_NAMESPACE               Doc::alias("namespace")+
−
#define COMMAND_OVERLOAD                Doc::alias("overload")+
−
#define COMMAND_NEXTPAGE                Doc::alias("nextpage")+
−
#define COMMAND_PAGE                    Doc::alias("page")+
−
#define COMMAND_PREVIOUSPAGE            Doc::alias("previouspage")+
−
#define COMMAND_PROPERTY                Doc::alias("property")+
−
#define COMMAND_REIMP                   Doc::alias("reimp")+
−
#define COMMAND_RELATES                 Doc::alias("relates")+
−
#define COMMAND_SERVICE                 Doc::alias("service")+
−
#define COMMAND_STARTPAGE               Doc::alias("startpage")+
−
#define COMMAND_TYPEDEF                 Doc::alias("typedef")+
−
#define COMMAND_VARIABLE                Doc::alias("variable")+
−
+
−
#ifdef QDOC_QML+
−
#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+
−
+
−
QStringList CppCodeParser::exampleFiles;+
−
QStringList CppCodeParser::exampleDirs;+
−
+
−
static void extractPageLinkAndDesc(const QString &arg,+
−
                                   QString *link,+
−
                                   QString *desc)+
−
{+
−
    QRegExp bracedRegExp("\\{([^{}]*)\\}(?:\\{([^{}]*)\\})?");+
−
+
−
    if (bracedRegExp.exactMatch(arg)) {+
−
        *link = bracedRegExp.cap(1);+
−
        *desc = bracedRegExp.cap(2);+
−
        if (desc->isEmpty())+
−
            *desc = *link;+
−
    }+
−
    else {+
−
        int spaceAt = arg.indexOf(" ");+
−
        if (arg.contains(".html") && spaceAt != -1) {+
−
            *link = arg.left(spaceAt).trimmed();+
−
            *desc = arg.mid(spaceAt).trimmed();+
−
        }+
−
        else {+
−
            *link = arg;+
−
            *desc = arg;+
−
        }+
−
    }+
−
}+
−
+
−
static void setLink(Node *node, Node::LinkType linkType, const QString &arg)+
−
{+
−
    QString link;+
−
    QString desc;+
−
    extractPageLinkAndDesc(arg, &link, &desc);+
−
    node->setLink(linkType, link, desc);+
−
}+
−
+
−
/*+
−
    This is used for fuzzy matching only, which in turn is only used+
−
    for Qt Jambi.+
−
*/+
−
static QString cleanType(const QString &type, const Tree *tree)+
−
{+
−
    QString result = type;+
−
    result.replace("qlonglong", "long long");+
−
    result.replace("qulonglong", "unsigned long long");+
−
    result.replace("qreal", "double");+
−
    result.replace(QRegExp("\\bu(int|short|char|long)\\b"), "unsigned \\1");+
−
    result.replace("QRgb", "unsigned int");+
−
    result.replace(" >", ">");+
−
    result.remove(" const[]");+
−
    result.replace("QStringList<QString>", "QStringList");+
−
    result.replace("qint8", "char");+
−
    result.replace("qint16", "short");+
−
    result.replace("qint32", "int");+
−
    result.replace("qint64", "long long");+
−
    result.replace("quint8", "unsigned char");+
−
    result.replace("quint16", "unsigned short");+
−
    result.replace("quint32", "unsigned int");+
−
    result.replace("quint64", "unsigned long long");+
−
+
−
    if (result.contains("QFlags")) {+
−
        QRegExp regExp("QFlags<(((?:[^<>]+::)*)([^<>:]+))>");+
−
        int pos = 0;+
−
        while ((pos = result.indexOf(regExp, pos)) != -1) {+
−
            // we assume that the path for the associated enum+
−
            // is the same as for the flag typedef+
−
            QStringList path = regExp.cap(2).split("::",+
−
                                                   QString::SkipEmptyParts);+
−
            const EnumNode *enume = static_cast<const EnumNode *>(+
−
                             tree->findNode(QStringList(path) << regExp.cap(3),+
−
                                            Node::Enum));+
−
            if (enume && enume->flagsType())+
−
                result.replace(pos, regExp.matchedLength(),+
−
                 (QStringList(path) << enume->flagsType()->name()).join("::"));+
−
            ++pos;+
−
        }+
−
    }+
−
    if (result.contains("::")) {+
−
        // remove needless (and needful) class prefixes+
−
        QRegExp regExp("[A-Za-z0-9_]+::");+
−
        result.replace(regExp, "");+
−
    }+
−
    return result;+
−
}+
−
+
−
/*!+
−
  The constructor initializes some regular expressions+
−
  and calls reset().+
−
 */+
−
CppCodeParser::CppCodeParser()+
−
    : varComment("/\\*\\s*([a-zA-Z_0-9]+)\\s*\\*/"), sep("(?:<[^>]+>)?::")+
−
{+
−
    reset(0);+
−
}+
−
+
−
/*!+
−
  The destructor is trivial.+
−
 */+
−
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)+
−
{+
−
    CodeParser::initializeParser(config);+
−
+
−
    nodeTypeMap.insert(COMMAND_NAMESPACE, Node::Namespace);+
−
    nodeTypeMap.insert(COMMAND_CLASS, Node::Class);+
−
    nodeTypeMap.insert(COMMAND_SERVICE, Node::Class);+
−
    nodeTypeMap.insert(COMMAND_ENUM, Node::Enum);+
−
    nodeTypeMap.insert(COMMAND_TYPEDEF, Node::Typedef);+
−
    nodeTypeMap.insert(COMMAND_PROPERTY, Node::Property);+
−
    nodeTypeMap.insert(COMMAND_VARIABLE, Node::Variable);+
−
+
−
    exampleFiles = config.getStringList(CONFIG_EXAMPLES);+
−
    exampleDirs = config.getStringList(CONFIG_EXAMPLEDIRS);+
−
    QStringList exampleFilePatterns = config.getStringList(+
−
        CONFIG_EXAMPLES + Config::dot + CONFIG_FILEEXTENSIONS);+
−
+
−
    if (!exampleFilePatterns.isEmpty())+
−
        exampleNameFilter = exampleFilePatterns.join(" ");+
−
    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()+
−
{+
−
    nodeTypeMap.clear();+
−
    CodeParser::terminateParser();+
−
}+
−
+
−
/*!+
−
  Returns "Cpp".+
−
 */+
−
QString CppCodeParser::language()+
−
{+
−
    return "Cpp";+
−
}+
−
+
−
/*!+
−
  Returns a list of extensions for header files.+
−
 */+
−
QString CppCodeParser::headerFileNameFilter()+
−
{+
−
    return "*.ch *.h *.h++ *.hh *.hpp *.hxx";+
−
}+
−
+
−
/*!+
−
  Returns a list of extensions for source files, i.e. not+
−
  header files.+
−
 */+
−
QString CppCodeParser::sourceFileNameFilter()+
−
{+
−
    return "*.c++ *.cc *.cpp *.cxx";+
−
}+
−
+
−
/*!+
−
  Parse the C++ header file identified by \a filePath+
−
  and add the parsed contents to the big \a tree. The+
−
  \a location is used for reporting errors.+
−
 */+
−
void CppCodeParser::parseHeaderFile(const Location& location,+
−
                                    const QString& filePath,+
−
                                    Tree *tree)+
−
{+
−
    FILE *in = fopen(QFile::encodeName(filePath), "r");+
−
    if (!in) {+
−
        location.error(tr("Cannot open C++ header file '%1'").arg(filePath));+
−
        return;+
−
    }+
−
+
−
    reset(tree);+
−
    Location fileLocation(filePath);+
−
    Tokenizer fileTokenizer(fileLocation, in);+
−
    tokenizer = &fileTokenizer;+
−
    readToken();+
−
    matchDeclList(tree->root());+
−
    if (!fileTokenizer.version().isEmpty())+
−
        tree->setVersion(fileTokenizer.version());+
−
    fclose(in);+
−
+
−
    if (fileLocation.fileName() == "qiterator.h")+
−
        parseQiteratorDotH(location, filePath);+
−
}+
−
+
−
/*!+
−
  Get ready to parse the C++ cpp file identified by \a filePath+
−
  and add its parsed contents to the big \a tree. \a location is+
−
  used for reporting errors.+
−
+
−
  Call matchDocsAndStuff() to do all the parsing and tree building.+
−
 */+
−
void CppCodeParser::parseSourceFile(const Location& location,+
−
                                    const QString& filePath,+
−
                                    Tree *tree)+
−
{+
−
    FILE *in = fopen(QFile::encodeName(filePath), "r");+
−
    if (!in) {+
−
        location.error(tr("Cannot open C++ source file '%1' (%2)").arg(filePath).arg(strerror(errno)));+
−
        return;+
−
    }+
−
+
−
    reset(tree);+
−
    Location fileLocation(filePath);+
−
    Tokenizer fileTokenizer(fileLocation, in);+
−
    tokenizer = &fileTokenizer;+
−
    readToken();+
−
    usedNamespaces.clear();+
−
    matchDocsAndStuff();+
−
    fclose(in);+
−
}+
−
+
−
/*!+
−
  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)+
−
{+
−
    tree->resolveInheritance();+
−
+
−
    QMapIterator<QString, QString> i(sequentialIteratorClasses);+
−
    while (i.hasNext()) {+
−
        i.next();+
−
        instantiateIteratorMacro(i.key(),+
−
                                 i.value(),+
−
                                 sequentialIteratorDefinition,+
−
                                 tree);+
−
    }+
−
    i = mutableSequentialIteratorClasses;+
−
    while (i.hasNext()) {+
−
        i.next();+
−
        instantiateIteratorMacro(i.key(),+
−
                                 i.value(),+
−
                                 mutableSequentialIteratorDefinition,+
−
                                 tree);+
−
    }+
−
    i = associativeIteratorClasses;+
−
    while (i.hasNext()) {+
−
        i.next();+
−
        instantiateIteratorMacro(i.key(),+
−
                                 i.value(),+
−
                                 associativeIteratorDefinition,+
−
                                 tree);+
−
    }+
−
    i = mutableAssociativeIteratorClasses;+
−
    while (i.hasNext()) {+
−
        i.next();+
−
        instantiateIteratorMacro(i.key(),+
−
                                 i.value(),+
−
                                 mutableAssociativeIteratorDefinition,+
−
                                 tree);+
−
    }+
−
    sequentialIteratorDefinition.clear();+
−
    mutableSequentialIteratorDefinition.clear();+
−
    associativeIteratorDefinition.clear();+
−
    mutableAssociativeIteratorDefinition.clear();+
−
    sequentialIteratorClasses.clear();+
−
    mutableSequentialIteratorClasses.clear();+
−
    associativeIteratorClasses.clear();+
−
    mutableAssociativeIteratorClasses.clear();+
−
}+
−
+
−
/*!+
−
  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)+
−
{+
−
    tree->root()->makeUndocumentedChildrenInternal();+
−
    tree->root()->normalizeOverloads();+
−
    tree->fixInheritance();+
−
    tree->resolveProperties();+
−
}+
−
+
−
/*!+
−
  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,+
−
                                                    Node *relative,+
−
                                                    bool fuzzy)+
−
{+
−
    QStringList parentPath;+
−
    FunctionNode *clone;+
−
    FunctionNode *func = 0;+
−
    int flags = fuzzy ? int(Tree::SearchBaseClasses) : 0;+
−
+
−
    reset(tree);+
−
    if (makeFunctionNode(synopsis, &parentPath, &clone)) {+
−
        func = tree->findFunctionNode(parentPath, clone, relative, flags);+
−
+
−
        /*+
−
            This is necessary because Roberto's parser resolves typedefs.+
−
        */+
−
        if (!func && fuzzy) {+
−
            func = tre->findFunctionNode(parentPath ++
−
                                         QStringList(clone->name()),+
−
                                         relative,+
−
                                         flags);+
−
            if (!func && clone->name().contains('_')) {+
−
                QStringList path = parentPath;+
−
                path << clone->name().split('_');+
−
                func = tre->findFunctionNode(path, relative, flags);+
−
            }+
−
+
−
            if (func) {+
−
                NodeList overloads = func->parent()->overloads(func->name());+
−
                NodeList candidates;+
−
                for (int i = 0; i < overloads.count(); ++i) {+
−
                    FunctionNode *overload = static_cast<FunctionNode *>(overloads.at(i));+
−
                    if (overload->status() != Node::Compat+
−
                            && overload->parameters().count() == clone->parameters().count()+
−
                            && !overload->isConst() == !clone->isConst())+
−
                        candidates << overload;+
−
                }+
−
                if (candidates.count() == 0)+
−
                    return 0;+
−
+
−
                /*+
−
                    There's only one function with the correct number+
−
                    of parameters. That must be the one.+
−
                */+
−
                if (candidates.count() == 1)+
−
                    return static_cast<FunctionNode *>(candidates.first());+
−
+
−
                overloads = candidates;+
−
                candidates.clear();+
−
                for (int i = 0; i < overloads.count(); ++i) {+
−
                    FunctionNode *overload = static_cast<FunctionNode *>(overloads.at(i));+
−
                    QList<Parameter> params1 = overload->parameters();+
−
                    QList<Parameter> params2 = clone->parameters();+
−
+
−
                    int j;+
−
                    for (j = 0; j < params1.count(); ++j) {+
−
                        if (!params2.at(j).name().startsWith(params1.at(j).name()))+
−
                            break;+
−
                    }+
−
                    if (j == params1.count())+
−
                        candidates << overload;+
−
                }+
−
+
−
                /*+
−
                    There are several functions with the correct+
−
                    parameter count, but only one has the correct+
−
                    parameter names.+
−
                */+
−
                if (candidates.count() == 1)+
−
                    return static_cast<FunctionNode *>(candidates.first());+
−
+
−
                candidates.clear();+
−
                for (int i = 0; i < overloads.count(); ++i) {+
−
                    FunctionNode *overload = static_cast<FunctionNode *>(overloads.at(i));+
−
                    QList<Parameter> params1 = overload->parameters();+
−
                    QList<Parameter> params2 = clone->parameters();+
−
+
−
                    int j;+
−
                    for (j = 0; j < params1.count(); ++j) {+
−
                        if (params1.at(j).rightType() != params2.at(j).rightType())+
−
                            break;+
−
+
−
                        if (cleanType(params1.at(j).leftType(), tree)+
−
                                != cleanType(params2.at(j).leftType(), tree))+
−
                            break;+
−
                    }+
−
                    if (j == params1.count())+
−
                        candidates << overload;+
−
                }+
−
+
−
                +
−
                /*+
−
                    There are several functions with the correct+
−
                    parameter count, but only one has the correct+
−
                    types, loosely compared.+
−
                */+
−
                if (candidates.count() == 1)+
−
                    return static_cast<FunctionNode *>(candidates.first());+
−
+
−
                return 0;+
−
            }+
−
        }+
−
        delete clone;+
−
    }+
−
    return func;+
−
}+
−
+
−
/*!+
−
  Returns the set of strings reopresenting the topic commands.+
−
 */+
−
QSet<QString> CppCodeParser::topicCommands()+
−
{+
−
    return QSet<QString>() << COMMAND_CLASS+
−
                           << COMMAND_ENUM+
−
                           << COMMAND_EXAMPLE+
−
                           << COMMAND_EXTERNALPAGE+
−
                           << COMMAND_FILE+
−
                           << COMMAND_FN+
−
                           << COMMAND_GROUP+
−
                           << COMMAND_HEADERFILE+
−
                           << COMMAND_MACRO+
−
                           << COMMAND_MODULE+
−
                           << COMMAND_NAMESPACE+
−
                           << COMMAND_PAGE+
−
                           << COMMAND_PROPERTY+
−
                           << COMMAND_SERVICE+
−
                           << COMMAND_TYPEDEF+
−
#ifdef QDOC_QML+
−
                           << COMMAND_VARIABLE+
−
                           << COMMAND_QMLCLASS+
−
                           << COMMAND_QMLPROPERTY+
−
                           << COMMAND_QMLATTACHEDPROPERTY+
−
                           << COMMAND_QMLSIGNAL+
−
                           << COMMAND_QMLATTACHEDSIGNAL+
−
                           << COMMAND_QMLMETHOD+
−
                           << COMMAND_QMLATTACHEDMETHOD;+
−
#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)+
−
{+
−
    if (command == COMMAND_FN) {+
−
        QStringList parentPath;+
−
        FunctionNode *func = 0;+
−
        FunctionNode *clone = 0;+
−
+
−
        if (!makeFunctionNode(arg, &parentPath, &clone) &&+
−
             !makeFunctionNode("void " + arg, &parentPath, &clone)) {+
−
            doc.location().warning(tr("Invalid syntax in '\\%1'")+
−
                                    .arg(COMMAND_FN));+
−
        }+
−
        else {+
−
            if (!usedNamespaces.isEmpty()) {+
−
                foreach (const QString &usedNamespace, usedNamespaces) {+
−
                    QStringList newPath = usedNamespace.split("::") + parentPath;+
−
                    func = tre->findFunctionNode(newPath, clone);+
−
                    if (func)+
−
                        break;+
−
                }+
−
            }+
−
            // Search the root namespace if no match was found.+
−
            if (func == 0)+
−
                func = tre->findFunctionNode(parentPath, clone);+
−
+
−
            if (func == 0) {+
−
                if (parentPath.isEmpty() && !lastPath.isEmpty())+
−
                    func = tre->findFunctionNode(lastPath, clone);+
−
                if (func == 0) {+
−
                    doc.location().warning(tr("Cannot find '%1' in '\\%2'")+
−
                                           .arg(clone->name() + "(...)")+
−
                                           .arg(COMMAND_FN),+
−
                                           tr("I cannot find any function of that name with the "+
−
                                              "specified signature. Make sure that the signature "+
−
                                              "is identical to the declaration, including 'const' "+
−
                                              "qualifiers."));+
−
                }+
−
                else {+
−
                    doc.location().warning(tr("Missing '%1::' for '%2' in '\\%3'")+
−
                                            .arg(lastPath.join("::"))+
−
                                            .arg(clone->name() + "()")+
−
                                            .arg(COMMAND_FN));+
−
                }+
−
            }+
−
            else {+
−
                lastPath = parentPath;+
−
            }+
−
            if (func) {+
−
                func->borrowParameterNames(clone);+
−
                func->setParentPath(clone->parentPath());+
−
            }+
−
            delete clone;+
−
        }+
−
        return func;+
−
    }+
−
    else if (command == COMMAND_MACRO) {+
−
        QStringList parentPath;+
−
        FunctionNode *func = 0;+
−
+
−
        if (makeFunctionNode(arg, &parentPath, &func, tre->root())) {+
−
            if (!parentPath.isEmpty()) {+
−
                doc.location().warning(tr("Invalid syntax in '\\%1'")+
−
                                        .arg(COMMAND_MACRO));+
−
                delete func;+
−
                func = 0;+
−
            }+
−
            else {+
−
                func->setMetaness(FunctionNode::MacroWithParams);+
−
                QList<Parameter> params = func->parameters();+
−
                for (int i = 0; i < params.size(); ++i) {+
−
                    Parameter &param = params[i];+
−
                    if (param.name().isEmpty() && !param.leftType().isEmpty()+
−
                            && param.leftType() != "...")+
−
                        param = Parameter("", "", param.leftType());+
−
                }+
−
                func->setParameters(params);+
−
            }+
−
            return func;+
−
        }+
−
        else if (QRegExp("[A-Za-z_][A-Za-z0-9_]+").exactMatch(arg)) {+
−
            func = new FunctionNode(tre->root(), arg);+
−
            func->setAccess(Node::Public);+
−
            func->setLocation(doc.location());+
−
            func->setMetaness(FunctionNode::MacroWithoutParams);+
−
        }+
−
        else {+
−
            doc.location().warning(tr("Invalid syntax in '\\%1'")+
−
                                    .arg(COMMAND_MACRO));+
−
+
−
        }+
−
        return func;+
−
    }+
−
    else if (nodeTypeMap.contains(command)) {+
−
        /*+
−
          The command was neither "fn" nor "macro" .+
−
         */+
−
        // ### split(" ") hack is there to support header file syntax+
−
        QStringList paths = arg.split(" ");+
−
        QStringList path = paths[0].split("::");+
−
        Node *node = 0;+
−
        if (!usedNamespaces.isEmpty()) {+
−
            foreach (const QString &usedNamespace, usedNamespaces) {+
−
                QStringList newPath = usedNamespace.split("::") + path;+
−
                node = tre->findNode(newPath, nodeTypeMap[command]);+
−
                if (node) {+
−
                    path = newPath;+
−
                    break;+
−
                }+
−
            }+
−
        }+
−
        // Search the root namespace if no match was found.+
−
        if (node == 0)+
−
            node = tre->findNode(path, nodeTypeMap[command]);+
−
+
−
        if (node == 0) {+
−
            doc.location().warning(tr("Cannot find '%1' specified with '\\%2' in any header file")+
−
                                   .arg(arg).arg(command));+
−
            lastPath = path;+
−
+
−
        }+
−
        else if (command == COMMAND_SERVICE) {+
−
            // If the command is "\service", then we need to tag the+
−
            // class with the actual service name.+
−
            QStringList args = arg.split(" ");+
−
            if (args.size() > 1) {+
−
                ClassNode *cnode = static_cast<ClassNode *>(node);+
−
                cnode->setServiceName(args[1]);+
−
                cnode->setHideFromMainList(true);+
−
            }+
−
        }+
−
        else if (node->isInnerNode()) {+
−
            if (path.size() > 1) {+
−
                path.pop_back();+
−
                usedNamespaces.insert(path.join("::"));+
−
            }+
−
        }+
−
+
−
        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, Node::Example);+
−
        createExampleFileNodes(fake);+
−
        return fake;+
−
    }+
−
    else if (command == COMMAND_EXTERNALPAGE) {+
−
        return new FakeNode(tre->root(), arg, Node::ExternalPage);+
−
    }+
−
    else if (command == COMMAND_FILE) {+
−
        return new FakeNode(tre->root(), arg, Node::File);+
−
    }+
−
    else if (command == COMMAND_GROUP) {+
−
        return new FakeNode(tre->root(), arg, Node::Group);+
−
    }+
−
    else if (command == COMMAND_HEADERFILE) {+
−
        return new FakeNode(tre->root(), arg, Node::HeaderFile);+
−
    }+
−
    else if (command == COMMAND_MODULE) {+
−
        return new FakeNode(tre->root(), arg, Node::Module);+
−
    }+
−
    else if (command == COMMAND_PAGE) {+
−
        return new FakeNode(tre->root(), arg, Node::Page);+
−
    }+
−
#ifdef QDOC_QML+
−
    else if (command == COMMAND_QMLCLASS) {+
−
        const ClassNode* classNode = 0;+
−
        QStringList names = arg.split(" ");+
−
        if (names.size() > 1) {+
−
            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_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+
−
+
−
/*!+
−
  Returns the set of strings representing the common metacommands+
−
  plus some other metacommands.+
−
 */+
−
QSet<QString> CppCodeParser::otherMetaCommands()+
−
{+
−
    return commonMetaCommands() << COMMAND_INHEADERFILE+
−
                                << COMMAND_OVERLOAD+
−
                                << COMMAND_REIMP+
−
                                << 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.+
−
  \a arg is the argument to the metacommand.+
−
 */+
−
void CppCodeParser::processOtherMetaCommand(const Doc& doc,+
−
                                            const QString& command,+
−
                                            const QString& arg,+
−
                                            Node *node)+
−
{+
−
    if (command == COMMAND_INHEADERFILE) {+
−
        if (node != 0 && node->isInnerNode()) {+
−
            ((InnerNode *) node)->addInclude(arg);+
−
        }+
−
        else {+
−
            doc.location().warning(tr("Ignored '\\%1'")+
−
                                   .arg(COMMAND_INHEADERFILE));+
−
        }+
−
    }+
−
    else if (command == COMMAND_OVERLOAD) {+
−
        if (node != 0 && node->type() == Node::Function) {+
−
            ((FunctionNode *) node)->setOverload(true);+
−
        }+
−
        else {+
−
            doc.location().warning(tr("Ignored '\\%1'")+
−
                                   .arg(COMMAND_OVERLOAD));+
−
        }+
−
    }+
−
    else if (command == COMMAND_REIMP) {+
−
        if (node != 0 && node->type() == Node::Function) {+
−
            FunctionNode *func = (FunctionNode *) node;+
−
            const FunctionNode *from = func->reimplementedFrom();+
−
            if (from == 0) {+
−
                doc.location().warning(+
−
                    tr("Cannot find base function for '\\%1' in %2()")+
−
                    .arg(COMMAND_REIMP).arg(node->name()),+
−
                    tr("The function either doesn't exist in any base class "+
−
                       "with the same signature or it exists but isn't virtual."));+
−
            }+
−
            /*+
−
              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("'\\%1' in %2() should be '\\internal' because its base function is private or internal")+
−
                    .arg(COMMAND_REIMP).arg(node->name()));+
−
            }+
−
+
−
#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 {+
−
            doc.location().warning(tr("Ignored '\\%1' in %2")+
−
                                   .arg(COMMAND_REIMP)+
−
                                   .arg(node->name()));+
−
        }+
−
    }+
−
    else if (command == COMMAND_RELATES) {+
−
        InnerNode *pseudoParent;+
−
        if (arg.startsWith("<") || arg.startsWith("\"")) {+
−
            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));+
−
            if (!pseudoParent)+
−
                pseudoParent =+
−
                    static_cast<InnerNode*>(tre->findNode(QStringList(newPath),+
−
                                                          Node::Namespace));+
−
        }+
−
        if (!pseudoParent) {+
−
            doc.location().warning(tr("Cannot find '%1' in '\\%2'")+
−
                                   .arg(arg).arg(COMMAND_RELATES));+
−
        }+
−
        else {+
−
            node->setRelates(pseudoParent);+
−
        }+
−
    }+
−
    else if (command == COMMAND_CONTENTSPAGE) {+
−
        setLink(node, Node::ContentsLink, arg);+
−
    }+
−
    else if (command == COMMAND_NEXTPAGE) {+
−
        setLink(node, Node::NextLink, arg);+
−
    }+
−
    else if (command == COMMAND_PREVIOUSPAGE) {+
−
        setLink(node, Node::PreviousLink, arg);+
−
    }+
−
    else if (command == COMMAND_INDEXPAGE) {+
−
        setLink(node, Node::IndexLink, arg);+
−
    }+
−
    else if (command == COMMAND_STARTPAGE) {+
−
        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);+
−
    }+
−
}+
−
+
−
/*!+
−
  The topic command has been processed resulting in the \a doc+
−
  and \a node passed in here. Process the other meta commands,+
−
  which are found in \a doc, in the context of the topic \a node.+
−
 */+
−
void CppCodeParser::processOtherMetaCommands(const Doc& doc, Node *node)+
−
{+
−
    const QSet<QString> metaCommands = doc.metaCommandsUsed();+
−
    QSet<QString>::ConstIterator cmd = metaCommands.begin();+
−
    while (cmd != metaCommands.end()) {+
−
        QStringList args = doc.metaCommandArgs(*cmd);+
−
        QStringList::ConstIterator arg = args.begin();+
−
        while (arg != args.end()) {+
−
            processOtherMetaCommand(doc, *cmd, *arg, node);+
−
            ++arg;+
−
        }+
−
        ++cmd;+
−
    }+
−
}+
−
+
−
/*!+
−
  Resets the C++ code parser to its default initialized state.+
−
 */+
−
void CppCodeParser::reset(Tree *tree)+
−
{+
−
    tre = tree;+
−
    tokenizer = 0;+
−
    tok = 0;+
−
    access = Node::Public;+
−
    metaness = FunctionNode::Plain;+
−
    lastPath.clear();+
−
    moduleName = "";+
−
}+
−
+
−
/*!+
−
  Get the next token from the file being parsed and store it+
−
  in the token variable.+
−
 */+
−
void CppCodeParser::readToken()+
−
{+
−
    tok = tokenizer->getToken();+
−
}+
−
+
−
/*!+
−
  Return the current location in the file being parsed,+
−
  i.e. the file name, line number, and column number.+
−
 */+
−
const Location& CppCodeParser::location()+
−
{+
−
    return tokenizer->location();+
−
}+
−
+
−
/*!+
−
  Return the previous string read from the file being parsed.+
−
 */+
−
QString CppCodeParser::previousLexeme()+
−
{+
−
    return tokenizer->previousLexeme();+
−
}+
−
+
−
/*!+
−
  Return the current string string from the file being parsed.+
−
 */+
−
QString CppCodeParser::lexeme()+
−
{+
−
    return tokenizer->lexeme();+
−
}+
−
+
−
bool CppCodeParser::match(int target)+
−
{+
−
    if (tok == target) {+
−
        readToken();+
−
        return true;+
−
    }+
−
    else+
−
        return false;+
−
}+
−
+
−
/*!+
−
  If the current token is one of the keyword thingees that+
−
  are used in Qt, skip over it to the next token and return+
−
  true. Otherwise just return false without reading the+
−
  next token.+
−
 */+
−
bool CppCodeParser::matchCompat()+
−
{+
−
    switch (tok) {+
−
    case Tok_QT_COMPAT:+
−
    case Tok_QT_COMPAT_CONSTRUCTOR:+
−
    case Tok_QT_DEPRECATED:+
−
    case Tok_QT_MOC_COMPAT:+
−
    case Tok_QT3_SUPPORT:+
−
    case Tok_QT3_SUPPORT_CONSTRUCTOR:+
−
    case Tok_QT3_MOC_SUPPORT:+
−
        readToken();+
−
        return true;+
−
    default:+
−
        return false;+
−
    }+
−
}+
−
+
−
bool CppCodeParser::matchTemplateAngles(CodeChunk *dataType)+
−
{+
−
    bool matches = (tok == Tok_LeftAngle);+
−
    if (matches) {+
−
        int leftAngleDepth = 0;+
−
        int parenAndBraceDepth = 0;+
−
        do {+
−
            if (tok == Tok_LeftAngle) {+
−
                leftAngleDepth++;+
−
            }+
−
            else if (tok == Tok_RightAngle) {+
−
                leftAngleDepth--;+
−
            }+
−
            else if (tok == Tok_LeftParen || tok == Tok_LeftBrace) {+
−
                ++parenAndBraceDepth;+
−
            }+
−
            else if (tok == Tok_RightParen || tok == Tok_RightBrace) {+
−
                if (--parenAndBraceDepth < 0)+
−
                    return false;+
−
            }+
−
+
−
            if (dataType != 0)+
−
                dataType->append(lexeme());+
−
            readToken();+
−
        } while (leftAngleDepth > 0 && tok != Tok_Eoi);+
−
    }+
−
    return matches;+
−
}+
−
+
−
bool CppCodeParser::matchTemplateHeader()+
−
{+
−
    readToken();+
−
    return matchTemplateAngles();+
−
}+
−
+
−
bool CppCodeParser::matchDataType(CodeChunk *dataType, QString *var)+
−
{+
−
    /*+
−
      This code is really hard to follow... sorry. The loop is there to match+
−
      Alpha::Beta::Gamma::...::Omega.+
−
    */+
−
    for (;;) {+
−
        bool virgin = true;+
−
+
−
        if (tok != Tok_Ident) {+
−
            /*+
−
              There is special processing for 'Foo::operator int()'+
−
              and such elsewhere. This is the only case where we+
−
              return something with a trailing gulbrandsen ('Foo::').+
−
            */+
−
            if (tok == Tok_operator)+
−
                return true;+
−
+
−
            /*+
−
              People may write 'const unsigned short' or+
−
              'short unsigned const' or any other permutation.+
−
            */+
−
            while (match(Tok_const) || match(Tok_volatile))+
−
                dataType->append(previousLexeme());+
−
            while (match(Tok_signed) || match(Tok_unsigned) ||+
−
                    match(Tok_short) || match(Tok_long) || match(Tok_int64)) {+
−
                dataType->append(previousLexeme());+
−
                virgin = false;+
−
            }+
−
            while (match(Tok_const) || match(Tok_volatile))+
−
                dataType->append(previousLexeme());+
−
+
−
            if (match(Tok_Tilde))+
−
                dataType->append(previousLexeme());+
−
        }+
−
+
−
        if (virgin) {+
−
            if (match(Tok_Ident))+
−
                dataType->append(previousLexeme());+
−
            else if (match(Tok_void) || match(Tok_int) || match(Tok_char) ||+
−
                      match(Tok_double) || match(Tok_Ellipsis))+
−
                dataType->append(previousLexeme());+
−
            else+
−
                return false;+
−
        }+
−
        else if (match(Tok_int) || match(Tok_char) || match(Tok_double)) {+
−
            dataType->append(previousLexeme());+
−
        }+
−
+
−
        matchTemplateAngles(dataType);+
−
+
−
        while (match(Tok_const) || match(Tok_volatile))+
−
            dataType->append(previousLexeme());+
−
+
−
        if (match(Tok_Gulbrandsen))+
−
            dataType->append(previousLexeme());+
−
        else+
−
            break;+
−
    }+
−
+
−
    while (match(Tok_Ampersand) || match(Tok_Aster) || match(Tok_const) ||+
−
            match(Tok_Caret))+
−
        dataType->append(previousLexeme());+
−
+
−
    if (match(Tok_LeftParenAster)) {+
−
        /*+
−
          A function pointer. This would be rather hard to handle without a+
−
          tokenizer hack, because a type can be followed with a left parenthesis+
−
          in some cases (e.g., 'operator int()'). The tokenizer recognizes '(*'+
−
          as a single token.+
−
        */+
−
        dataType->append(previousLexeme());+
−
        dataType->appendHotspot();+
−
        if (var != 0 && match(Tok_Ident))+
−
            *var = previousLexeme();+
−
        if (!match(Tok_RightParen) || tok != Tok_LeftParen)+
−
            return false;+
−
        dataType->append(previousLexeme());+
−
+
−
        int parenDepth0 = tokenizer->parenDepth();+
−
        while (tokenizer->parenDepth() >= parenDepth0 && tok != Tok_Eoi) {+
−
            dataType->append(lexeme());+
−
            readToken();+
−
        }+
−
        if (match(Tok_RightParen))+
−
            dataType->append(previousLexeme());+
−
    }+
−
    else {+
−
        /*+
−
          The common case: Look for an optional identifier, then for+
−
          some array brackets.+
−
        */+
−
        dataType->appendHotspot();+
−
+
−
        if (var != 0) {+
−
            if (match(Tok_Ident)) {+
−
                *var = previousLexeme();+
−
            }+
−
            else if (match(Tok_Comment)) {+
−
                /*+
−
                  A neat hack: Commented-out parameter names are+
−
                  recognized by qdoc. It's impossible to illustrate+
−
                  here inside a C-style comment, because it requires+
−
                  an asterslash. It's also impossible to illustrate+
−
                  inside a C++-style comment, because the explanation+
−
                  does not fit on one line.+
−
                */+
−
                if (varComment.exactMatch(previousLexeme()))+
−
                    *var = varComment.cap(1);+
−
            }+
−
        }+
−
+
−
        if (tok == Tok_LeftBracket) {+
−
            int bracketDepth0 = tokenizer->bracketDepth();+
−
            while ((tokenizer->bracketDepth() >= bracketDepth0 &&+
−
                     tok != Tok_Eoi) ||+
−
                    tok == Tok_RightBracket) {+
−
                dataType->append(lexeme());+
−
                readToken();+
−
            }+
−
        }+
−
    }+
−
    return true;+
−
}+
−
+
−
bool CppCodeParser::matchParameter(FunctionNode *func)+
−
{+
−
    CodeChunk dataType;+
−
    QString name;+
−
    CodeChunk defaultValue;+
−
+
−
    if (!matchDataType(&dataType, &name))+
−
        return false;+
−
    match(Tok_Comment);+
−
    if (match(Tok_Equal)) {+
−
        int parenDepth0 = tokenizer->parenDepth();+
−
+
−
        while (tokenizer->parenDepth() >= parenDepth0 &&+
−
                (tok != Tok_Comma ||+
−
                 tokenizer->parenDepth() > parenDepth0) &&+
−
                tok != Tok_Eoi) {+
−
            defaultValue.append(lexeme());+
−
            readToken();+
−
        }+
−
    }+
−
    func->addParameter(Parameter(dataType.toString(),+
−
                                 "",+
−
                                 name,+
−
                                 defaultValue.toString())); // ###+
−
    return true;+
−
}+
−
+
−
bool CppCodeParser::matchFunctionDecl(InnerNode *parent,+
−
                                      QStringList *parentPathPtr,+
−
                                      FunctionNode **funcPtr,+
−
                                      const QString &templateStuff,+
−
                                      Node::Type type,+
−
                                      bool attached)+
−
{+
−
    CodeChunk returnType;+
−
    QStringList parentPath;+
−
    QString name;+
−
+
−
    bool compat = false;+
−
+
−
    if (match(Tok_friend))+
−
        return false;+
−
    match(Tok_explicit);+
−
    if (matchCompat())+
−
        compat = true;+
−
    bool sta = false;+
−
    if (match(Tok_static)) {+
−
        sta = true;+
−
        if (matchCompat())+
−
            compat = true;+
−
    }+
−
    FunctionNode::Virtualness vir = FunctionNode::NonVirtual;+
−
    if (match(Tok_virtual)) {+
−
        vir = FunctionNode::ImpureVirtual;+
−
        if (matchCompat())+
−
            compat = true;+
−
    }+
−
+
−
    if (!matchDataType(&returnType)) {+
−
        if (tokenizer->parsingFnOrMacro()+
−
                && (match(Tok_Q_DECLARE_FLAGS) || match(Tok_Q_PROPERTY)))+
−
            returnType = CodeChunk(previousLexeme());+
−
        else {+
−
            return false;+
−
        }+
−
    }+
−
+
−
    if (returnType.toString() == "QBool")+
−
        returnType = CodeChunk("bool");+
−
+
−
    if (matchCompat())+
−
        compat = true;+
−
+
−
    if (tok == Tok_operator &&+
−
         (returnType.toString().isEmpty() ||+
−
          returnType.toString().endsWith("::"))) {+
−
        // 'QString::operator const char *()'+
−
        parentPath = returnType.toString().split(sep);+
−
        parentPath.removeAll(QString());+
−
        returnType = CodeChunk();+
−
        readToken();+
−
+
−
        CodeChunk restOfName;+
−
        if (tok != Tok_Tilde && matchDataType(&restOfName)) {+
−
            name = "operator " + restOfName.toString();+
−
        }+
−
        else {+
−
            name = previousLexeme() + lexeme();+
−
            readToken();+
−
            while (tok != Tok_LeftParen && tok != Tok_Eoi) {+
−
                name += lexeme();+
−
                readToken();+
−
            }+
−
        }+
−
        if (tok != Tok_LeftParen) {+
−
            return false;+
−
        }+
−
    }+
−
    else if (tok == Tok_LeftParen) {+
−
        // constructor or destructor+
−
        parentPath = returnType.toString().split(sep);+
−
        if (!parentPath.isEmpty()) {+
−
            name = parentPath.last();+
−
            parentPath.erase(parentPath.end() - 1);+
−
        }+
−
        returnType = CodeChunk();+
−
    }+
−
    else {+
−
        while (match(Tok_Ident)) {+
−
            name = previousLexeme();+
−
            matchTemplateAngles();+
−
+
−
            if (match(Tok_Gulbrandsen))+
−
                parentPath.append(name);+
−
            else+
−
                break;+
−
        }+
−
+
−
        if (tok == Tok_operator) {+
−
            name = lexeme();+
−
            readToken();+
−
            while (tok != Tok_Eoi) {+
−
                name += lexeme();+
−
                readToken();+
−
                if (tok == Tok_LeftParen)+
−
                    break;+
−
            }+
−
        }+
−
        if (parent && (tok == Tok_Semicolon ||+
−
                       tok == Tok_LeftBracket ||+
−
                       tok == Tok_Colon)+
−
                && access != Node::Private) {+
−
            if (tok == Tok_LeftBracket) {+
−
                returnType.appendHotspot();+
−
+
−
                int bracketDepth0 = tokenizer->bracketDepth();+
−
                while ((tokenizer->bracketDepth() >= bracketDepth0 &&+
−
                         tok != Tok_Eoi) ||+
−
                        tok == Tok_RightBracket) {+
−
                    returnType.append(lexeme());+
−
                    readToken();+
−
                }+
−
                if (tok != Tok_Semicolon) {+
−
                    return false;+
−
                }+
−
            }+
−
            else if (tok == Tok_Colon) {+
−
                returnType.appendHotspot();+
−
+
−
                while (tok != Tok_Semicolon && tok != Tok_Eoi) {+
−
                    returnType.append(lexeme());+
−
                    readToken();+
−
                }+
−
                if (tok != Tok_Semicolon) {+
−
                    return false;+
−
                }+
−
            }+
−
+
−
            VariableNode *var = new VariableNode(parent, name);+
−
            var->setAccess(access);+
−
            var->setLocation(location());+
−
            var->setLeftType(returnType.left());+
−
            var->setRightType(returnType.right());+
−
            if (compat)+
−
                var->setStatus(Node::Compat);+
−
            var->setStatic(sta);+
−
            return false;+
−
        }+
−
        if (tok != Tok_LeftParen) {+
−
            return false;+
−
        }+
−
    }+
−
    readToken();+
−
+
−
    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)+
−
        func->setStatus(Node::Compat);+
−
+
−
    func->setMetaness(metaness);+
−
    if (parent) {+
−
        if (name == parent->name()) {+
−
            func->setMetaness(FunctionNode::Ctor);+
−
        } else if (name.startsWith("~"))  {+
−
            func->setMetaness(FunctionNode::Dtor);+
−
        }+
−
    }+
−
    func->setStatic(sta);+
−
+
−
    if (tok != Tok_RightParen) {+
−
        do {+
−
            if (!matchParameter(func)) {+
−
                return false;+
−
            }+
−
        } while (match(Tok_Comma));+
−
    }+
−
    if (!match(Tok_RightParen)) {+
−
        return false;+
−
    }+
−
+
−
    func->setConst(match(Tok_const));+
−
+
−
    if (match(Tok_Equal) && match(Tok_Number))+
−
        vir = FunctionNode::PureVirtual;+
−
    func->setVirtualness(vir);+
−
+
−
    if (match(Tok_Colon)) {+
−
        while (tok != Tok_LeftBrace && tok != Tok_Eoi)+
−
            readToken();+
−
    }+
−
+
−
    if (!match(Tok_Semicolon) && tok != Tok_Eoi) {+
−
        int braceDepth0 = tokenizer->braceDepth();+
−
+
−
        if (!match(Tok_LeftBrace)) {+
−
            return false;+
−
        }+
−
        while (tokenizer->braceDepth() >= braceDepth0 && tok != Tok_Eoi)+
−
            readToken();+
−
        match(Tok_RightBrace);+
−
    }+
−
    if (parentPathPtr != 0)+
−
        *parentPathPtr = parentPath;+
−
    if (funcPtr != 0)+
−
        *funcPtr = func;+
−
    return true;+
−
}+
−
+
−
bool CppCodeParser::matchBaseSpecifier(ClassNode *classe, bool isClass)+
−
{+
−
    Node::Access access;+
−
+
−
    switch (tok) {+
−
    case Tok_public:+
−
        access = Node::Public;+
−
        readToken();+
−
        break;+
−
    case Tok_protected:+
−
        access = Node::Protected;+
−
        readToken();+
−
        break;+
−
    case Tok_private:+
−
        access = Node::Private;+
−
        readToken();+
−
        break;+
−
    default:+
−
        access = isClass ? Node::Private : Node::Public;+
−
    }+
−
+
−
    if (tok == Tok_virtual)+
−
        readToken();+
−
+
−
    CodeChunk baseClass;+
−
    if (!matchDataType(&baseClass))+
−
        return false;+
−
+
−
    tre->addBaseClass(classe,+
−
                      access,+
−
                      baseClass.toPath(),+
−
                      baseClass.toString(),+
−
                      classe->parent());+
−
    return true;+
−
}+
−
+
−
bool CppCodeParser::matchBaseList(ClassNode *classe, bool isClass)+
−
{+
−
    for (;;) {+
−
        if (!matchBaseSpecifier(classe, isClass))+
−
            return false;+
−
        if (tok == Tok_LeftBrace)+
−
            return true;+
−
        if (!match(Tok_Comma))+
−
            return false;+
−
    }+
−
}+
−
+
−
/*!+
−
  Parse a C++ class, union, or struct declarion.+
−
 */+
−
bool CppCodeParser::matchClassDecl(InnerNode *parent,+
−
                                   const QString &templateStuff)+
−
{+
−
    bool isClass = (tok == Tok_class);+
−
    readToken();+
−
+
−
    bool compat = matchCompat();+
−
+
−
    if (tok != Tok_Ident)+
−
        return false;+
−
    while (tok == Tok_Ident)+
−
        readToken();+
−
    if (tok != Tok_Colon && tok != Tok_LeftBrace)+
−
        return false;+
−
+
−
    /*+
−
      So far, so good. We have 'class Foo {' or 'class Foo :'.+
−
      This is enough to recognize a class definition.+
−
    */+
−
    ClassNode *classe = new ClassNode(parent, previousLexeme());+
−
    classe->setAccess(access);+
−
    classe->setLocation(location());+
−
    if (compat)+
−
        classe->setStatus(Node::Compat);+
−
    if (!moduleName.isEmpty())+
−
        classe->setModuleName(moduleName);+
−
    classe->setTemplateStuff(templateStuff);+
−
+
−
    if (match(Tok_Colon) && !matchBaseList(classe, isClass))+
−
        return false;+
−
    if (!match(Tok_LeftBrace))+
−
        return false;+
−
+
−
    Node::Access outerAccess = access;+
−
    access = isClass ? Node::Private : Node::Public;+
−
    FunctionNode::Metaness outerMetaness = metaness;+
−
    metaness = FunctionNode::Plain;+
−
+
−
    bool matches = (matchDeclList(classe) && match(Tok_RightBrace) &&+
−
                     match(Tok_Semicolon));+
−
    access = outerAccess;+
−
    metaness = outerMetaness;+
−
    return matches;+
−
}+
−
+
−
bool CppCodeParser::matchNamespaceDecl(InnerNode *parent)+
−
{+
−
    readToken(); // skip 'namespace'+
−
    if (tok != Tok_Ident)+
−
        return false;+
−
    while (tok == Tok_Ident)+
−
        readToken();+
−
    if (tok != Tok_LeftBrace)+
−
        return false;+
−
+
−
    /*+
−
        So far, so good. We have 'namespace Foo {'.+
−
    */+
−
    QString namespaceName = previousLexeme();+
−
    NamespaceNode *namespasse = 0;+
−
    if (parent)+
−
        namespasse = static_cast<NamespaceNode*>(parent->findNode(namespaceName, Node::Namespace));+
−
    if (!namespasse) {+
−
        namespasse = new NamespaceNode(parent, namespaceName);+
−
        namespasse->setAccess(access);+
−
        namespasse->setLocation(location());+
−
    }+
−
+
−
    readToken(); // skip '{'+
−
    bool matched = matchDeclList(namespasse);+
−
+
−
    return matched && match(Tok_RightBrace);+
−
}+
−
+
−
bool CppCodeParser::matchUsingDecl()+
−
{+
−
    readToken(); // skip 'using'+
−
+
−
    // 'namespace'+
−
    if (tok != Tok_namespace)+
−
        return false;+
−
+
−
    readToken();+
−
    // identifier+
−
    if (tok != Tok_Ident)+
−
        return false;+
−
+
−
    QString name;+
−
    while (tok == Tok_Ident) {+
−
        name += lexeme();+
−
        readToken();+
−
        if (tok == Tok_Semicolon)+
−
            break;+
−
        else if (tok != Tok_Gulbrandsen)+
−
            return false;+
−
        name += "::";+
−
        readToken();+
−
    }+
−
+
−
    /*+
−
        So far, so good. We have 'using namespace Foo;'.+
−
    */+
−
    usedNamespaces.insert(name);+
−
    return true;+
−
}+
−
+
−
bool CppCodeParser::matchEnumItem(InnerNode *parent, EnumNode *enume)+
−
{+
−
    if (!match(Tok_Ident))+
−
        return false;+
−
+
−
    QString name = previousLexeme();+
−
    CodeChunk val;+
−
+
−
    if (match(Tok_Equal)) {+
−
        while (tok != Tok_Comma && tok != Tok_RightBrace &&+
−
                tok != Tok_Eoi) {+
−
            val.append(lexeme());+
−
            readToken();+
−
        }+
−
    }+
−
+
−
    if (enume) {+
−
        QString strVal = val.toString();+
−
        if (strVal.isEmpty()) {+
−
            if (enume->items().isEmpty()) {+
−
                strVal = "0";+
−
            }+
−
            else {+
−
                QString last = enume->items().last().value();+
−
                bool ok;+
−
                int n = last.toInt(&ok);+
−
                if (ok) {+
−
                    if (last.startsWith("0") && last.size() > 1) {+
−
                        if (last.startsWith("0x") || last.startsWith("0X"))+
−
                            strVal = last.left(2) + QString::number(n + 1, 16);+
−
                        else+
−
                            strVal = "0" + QString::number(n + 1, 8);+
−
                    }+
−
                    else+
−
                        strVal = QString::number(n + 1);+
−
                }+
−
            }+
−
        }+
−
+
−
        enume->addItem(EnumItem(name, strVal));+
−
    }+
−
    else {+
−
        VariableNode *var = new VariableNode(parent, name);+
−
        var->setAccess(access);+
−
        var->setLocation(location());+
−
        var->setLeftType("const int");+
−
        var->setStatic(true);+
−
    }+
−
    return true;+
−
}+
−
+
−
bool CppCodeParser::matchEnumDecl(InnerNode *parent)+
−
{+
−
    QString name;+
−
+
−
    if (!match(Tok_enum))+
−
        return false;+
−
    if (match(Tok_Ident))+
−
        name = previousLexeme();+
−
    if (tok != Tok_LeftBrace)+
−
        return false;+
−
+
−
    EnumNode *enume = 0;+
−
+
−
    if (!name.isEmpty()) {+
−
        enume = new EnumNode(parent, name);+
−
        enume->setAccess(access);+
−
        enume->setLocation(location());+
−
    }+
−
+
−
    readToken();+
−
+
−
    if (!matchEnumItem(parent, enume))+
−
        return false;+
−
+
−
    while (match(Tok_Comma)) {+
−
        if (!matchEnumItem(parent, enume))+
−
            return false;+
−
    }+
−
    return match(Tok_RightBrace) && match(Tok_Semicolon);+
−
}+
−
+
−
bool CppCodeParser::matchTypedefDecl(InnerNode *parent)+
−
{+
−
    CodeChunk dataType;+
−
    QString name;+
−
+
−
    if (!match(Tok_typedef))+
−
        return false;+
−
    if (!matchDataType(&dataType, &name))+
−
        return false;+
−
    if (!match(Tok_Semicolon))+
−
        return false;+
−
+
−
    if (parent && !parent->findNode(name, Node::Typedef)) {+
−
        TypedefNode *typedeffe = new TypedefNode(parent, name);+
−
        typedeffe->setAccess(access);+
−
        typedeffe->setLocation(location());+
−
    }+
−
    return true;+
−
}+
−
+
−
bool CppCodeParser::matchProperty(InnerNode *parent)+
−
{+
−
    if (!match(Tok_Q_PROPERTY) &&+
−
        !match(Tok_Q_OVERRIDE) &&+
−
        !match(Tok_QDOC_PROPERTY))+
−
        return false;+
−
    if (!match(Tok_LeftParen))+
−
        return false;+
−
+
−
    QString name;+
−
    CodeChunk dataType;+
−
    if (!matchDataType(&dataType, &name))+
−
        return false;+
−
+
−
    PropertyNode *property = new PropertyNode(parent, name);+
−
    property->setAccess(Node::Public);+
−
    property->setLocation(location());+
−
    property->setDataType(dataType.toString());+
−
+
−
    while (tok != Tok_RightParen && tok != Tok_Eoi) {+
−
        if (!match(Tok_Ident))+
−
            return false;+
−
        QString key = previousLexeme();+
−
        QString value;+
−
+
−
        if (match(Tok_Ident)) {+
−
            value = previousLexeme();+
−
        }+
−
        else if (match(Tok_LeftParen)) {+
−
            int depth = 1;+
−
            while (tok != Tok_Eoi) {+
−
                if (tok == Tok_LeftParen) {+
−
                    readToken();+
−
                    ++depth;+
−
                } else if (tok == Tok_RightParen) {+
−
                    readToken();+
−
                    if (--depth == 0)+
−
                        break;+
−
                } else {+
−
                    readToken();+
−
                }+
−
            }+
−
            value = "?";+
−
        }+
−
+
−
        if (key == "READ")+
−
            tre->addPropertyFunction(property, value, PropertyNode::Getter);+
−
        else if (key == "WRITE") {+
−
            tre->addPropertyFunction(property, value, PropertyNode::Setter);+
−
            property->setWritable(true);+
−
        } else if (key == "STORED")+
−
            property->setStored(value.toLower() == "true");+
−
        else if (key == "DESIGNABLE")+
−
            property->setDesignable(value.toLower() == "true");+
−
        else if (key == "RESET")+
−
            tre->addPropertyFunction(property, value, PropertyNode::Resetter);+
−
        else if (key == "NOTIFY") {+
−
            tre->addPropertyFunction(property, value, PropertyNode::Notifier);+
−
        }+
−
+
−
    }+
−
    match(Tok_RightParen);+
−
    return true;+
−
}+
−
+
−
/*!+
−
  Parse a C++ declaration.+
−
 */+
−
bool CppCodeParser::matchDeclList(InnerNode *parent)+
−
{+
−
    QString templateStuff;+
−
    int braceDepth0 = tokenizer->braceDepth();+
−
    if (tok == Tok_RightBrace) // prevents failure on empty body+
−
        braceDepth0++;+
−
+
−
    while (tokenizer->braceDepth() >= braceDepth0 && tok != Tok_Eoi) {+
−
        switch (tok) {+
−
        case Tok_Colon:+
−
            readToken();+
−
            break;+
−
        case Tok_class:+
−
        case Tok_struct:+
−
        case Tok_union:+
−
            matchClassDecl(parent, templateStuff);+
−
            break;+
−
        case Tok_namespace:+
−
            matchNamespaceDecl(parent);+
−
            break;+
−
        case Tok_using:+
−
            matchUsingDecl();+
−
            break;+
−
        case Tok_template:+
−
            templateStuff = matchTemplateHeader();+
−
            continue;+
−
        case Tok_enum:+
−
            matchEnumDecl(parent);+
−
            break;+
−
        case Tok_typedef:+
−
            matchTypedefDecl(parent);+
−
            break;+
−
        case Tok_private:+
−
            readToken();+
−
            access = Node::Private;+
−
            metaness = FunctionNode::Plain;+
−
            break;+
−
        case Tok_protected:+
−
            readToken();+
−
            access = Node::Protected;+
−
            metaness = FunctionNode::Plain;+
−
            break;+
−
        case Tok_public:+
−
            readToken();+
−
            access = Node::Public;+
−
            metaness = FunctionNode::Plain;+
−
            break;+
−
        case Tok_signals:+
−
        case Tok_Q_SIGNALS:+
−
            readToken();+
−
            access = Node::Public;+
−
            metaness = FunctionNode::Signal;+
−
            break;+
−
        case Tok_slots:+
−
        case Tok_Q_SLOTS:+
−
            readToken();+
−
            metaness = FunctionNode::Slot;+
−
            break;+
−
        case Tok_Q_OBJECT:+
−
            readToken();+
−
            break;+
−
        case Tok_Q_OVERRIDE:+
−
        case Tok_Q_PROPERTY:+
−
        case Tok_QDOC_PROPERTY:+
−
            matchProperty(parent);+
−
            break;+
−
        case Tok_Q_DECLARE_SEQUENTIAL_ITERATOR:+
−
            readToken();+
−
            if (match(Tok_LeftParen) && match(Tok_Ident))+
−
                sequentialIteratorClasses.insert(previousLexeme(),+
−
                                                 location().fileName());+
−
            match(Tok_RightParen);+
−
            break;+
−
        case Tok_Q_DECLARE_MUTABLE_SEQUENTIAL_ITERATOR:+
−
            readToken();+
−
            if (match(Tok_LeftParen) && match(Tok_Ident))+
−
                mutableSequentialIteratorClasses.insert(previousLexeme(),+
−
                                                        location().fileName());+
−
            match(Tok_RightParen);+
−
            break;+
−
        case Tok_Q_DECLARE_ASSOCIATIVE_ITERATOR:+
−
            readToken();+
−
            if (match(Tok_LeftParen) && match(Tok_Ident))+
−
                associativeIteratorClasses.insert(previousLexeme(),+
−
                                                  location().fileName());+
−
            match(Tok_RightParen);+
−
            break;+
−
        case Tok_Q_DECLARE_MUTABLE_ASSOCIATIVE_ITERATOR:+
−
            readToken();+
−
            if (match(Tok_LeftParen) && match(Tok_Ident))+
−
                mutableAssociativeIteratorClasses.insert(previousLexeme(),+
−
                                                         location().fileName());+
−
            match(Tok_RightParen);+
−
            break;+
−
        case Tok_Q_DECLARE_FLAGS:+
−
            readToken();+
−
            if (match(Tok_LeftParen) && match(Tok_Ident)) {+
−
                QString flagsType = previousLexeme();+
−
                if (match(Tok_Comma) && match(Tok_Ident)) {+
−
                    QString enumType = previousLexeme();+
−
                    TypedefNode *flagsNode = new TypedefNode(parent, flagsType);+
−
                    flagsNode->setAccess(access);+
−
                    flagsNode->setLocation(location());+
−
                    EnumNode *enumNode =+
−
                        static_cast<EnumNode*>(parent->findNode(enumType,+
−
                                                                Node::Enum));+
−
                    if (enumNode)+
−
                        enumNode->setFlagsType(flagsNode);+
−
                }+
−
            }+
−
            match(Tok_RightParen);+
−
            break;+
−
        case Tok_QT_MODULE:+
−
            readToken();+
−
            if (match(Tok_LeftParen) && match(Tok_Ident))+
−
                moduleName = previousLexeme();+
−
            if (!moduleName.startsWith("Qt"))+
−
                moduleName.prepend("Qt");+
−
            match(Tok_RightParen);+
−
            break;+
−
        default:+
−
            if (!matchFunctionDecl(parent, 0, 0, templateStuff)) {+
−
                while (tok != Tok_Eoi &&+
−
                       (tokenizer->braceDepth() > braceDepth0 ||+
−
                        (!match(Tok_Semicolon) &&+
−
                         tok != Tok_public && tok != Tok_protected &&+
−
                         tok != Tok_private)))+
−
                    readToken();+
−
            }+
−
        }+
−
        templateStuff.clear();+
−
    }+
−
    return true;+
−
}+
−
+
−
/*!+
−
  This is called by parseSourceFile() to do the actual parsing+
−
  and tree building.+
−
 */+
−
bool CppCodeParser::matchDocsAndStuff()+
−
{+
−
    QSet<QString> topicCommandsAllowed = topicCommands();+
−
    QSet<QString> otherMetacommandsAllowed = otherMetaCommands();+
−
    QSet<QString> metacommandsAllowed = topicCommandsAllowed ++
−
        otherMetacommandsAllowed;+
−
+
−
    while (tok != Tok_Eoi) {+
−
        if (tok == Tok_Doc) {+
−
            /*+
−
              lexeme() returns an entire qdoc comment.+
−
             */+
−
            QString comment = lexeme();+
−
            Location start_loc(location());+
−
            readToken();+
−
+
−
            Doc::trimCStyleComment(start_loc,comment);+
−
            Location end_loc(location());+
−
+
−
            /*+
−
              Doc parses the comment.+
−
             */+
−
            Doc doc(start_loc,end_loc,comment,metacommandsAllowed);+
−
+
−
            QString topic;+
−
            QStringList args;+
−
+
−
            QSet<QString> topicCommandsUsed = topicCommandsAllowed &+
−
                doc.metaCommandsUsed();+
−
+
−
            /*+
−
              There should be one topic command in the set,+
−
              or none. If the set is empty, then the comment+
−
              should be a function description.+
−
             */+
−
            if (topicCommandsUsed.count() > 0) {+
−
                topic = *topicCommandsUsed.begin();+
−
                args = doc.metaCommandArgs(topic);+
−
            }+
−
+
−
            NodeList nodes;+
−
            QList<Doc> docs;+
−
+
−
            if (topic.isEmpty()) {+
−
                QStringList parentPath;+
−
                FunctionNode *clone;+
−
                FunctionNode *func = 0;+
−
+
−
                if (matchFunctionDecl(0, &parentPath, &clone)) {+
−
                    foreach (const QString &usedNamespace, usedNamespaces) {+
−
                        QStringList newPath = usedNamespace.split("::") + parentPath;+
−
                        func = tre->findFunctionNode(newPath, clone);+
−
                        if (func)+
−
                            break;+
−
                    }+
−
                    if (func == 0)+
−
                        func = tre->findFunctionNode(parentPath, clone);+
−
+
−
                    if (func) {+
−
                        func->borrowParameterNames(clone);+
−
                        nodes.append(func);+
−
                        docs.append(doc);+
−
                    }+
−
                    delete clone;+
−
                }+
−
                else {+
−
                    doc.location().warning(+
−
                       tr("Cannot tie this documentation to anything"),+
−
                       tr("I found a /*! ... */ comment, but there was no "+
−
                          "topic command (e.g., '\\%1', '\\%2') in the "+
−
                          "comment and no function definition following "+
−
                          "the comment.")+
−
                       .arg(COMMAND_FN).arg(COMMAND_PAGE));+
−
                }+
−
            }+
−
            else {+
−
                /*+
−
                  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()) {+
−
                    Doc nodeDoc = doc;+
−
                    Node *node = processTopicCommand(nodeDoc, topic, *a);+
−
                    if (node != 0) {+
−
                        nodes.append(node);+
−
                        docs.append(nodeDoc);+
−
                    }+
−
                    ++a;+
−
                }+
−
#endif                +
−
            }+
−
+
−
            NodeList::Iterator n = nodes.begin();+
−
            QList<Doc>::Iterator d = docs.begin();+
−
            while (n != nodes.end()) {+
−
                processOtherMetaCommands(*d, *n);+
−
                (*n)->setDoc(*d);+
−
                if ((*n)->isInnerNode() &&+
−
                    ((InnerNode *)*n)->includes().isEmpty()) {+
−
                    InnerNode *m = static_cast<InnerNode *>(*n);+
−
                    while (m->parent() != tre->root())+
−
                        m = m->parent();+
−
                    if (m == *n)+
−
                        ((InnerNode *)*n)->addInclude((*n)->name());+
−
                    else+
−
                        ((InnerNode *)*n)->setIncludes(m->includes());+
−
                }+
−
                ++d;+
−
                ++n;+
−
            }+
−
        }+
−
        else if (tok == Tok_using) {+
−
            matchUsingDecl();+
−
        }+
−
        else {+
−
            QStringList parentPath;+
−
            FunctionNode *clone;+
−
            FunctionNode *node = 0;+
−
+
−
            if (matchFunctionDecl(0, &parentPath, &clone)) {+
−
                /*+
−
                  The location of the definition is more interesting+
−
                  than that of the declaration. People equipped with+
−
                  a sophisticated text editor can respond to warnings+
−
                  concerning undocumented functions very quickly.+
−
+
−
                  Signals are implemented in uninteresting files+
−
                  generated by moc.+
−
                */+
−
                node = tre->findFunctionNode(parentPath, clone);+
−
                if (node != 0 && node->metaness() != FunctionNode::Signal)+
−
                    node->setLocation(clone->location());+
−
                delete clone;+
−
            }+
−
            else {+
−
                if (tok != Tok_Doc)+
−
                    readToken();+
−
            }+
−
        }+
−
    }+
−
    return true;+
−
}+
−
+
−
bool CppCodeParser::makeFunctionNode(const QString& synopsis,+
−
                                     QStringList *parentPathPtr,+
−
                                     FunctionNode **funcPtr,+
−
                                     InnerNode *root,+
−
                                     Node::Type type,+
−
                                     bool attached)+
−
{+
−
    Tokenizer *outerTokenizer = tokenizer;+
−
    int outerTok = tok;+
−
+
−
    Location loc;+
−
    QByteArray latin1 = synopsis.toLatin1();+
−
    Tokenizer stringTokenizer(loc, latin1);+
−
    stringTokenizer.setParsingFnOrMacro(true);+
−
    tokenizer = &stringTokenizer;+
−
    readToken();+
−
+
−
    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;+
−
}+
−
+
−
void CppCodeParser::parseQiteratorDotH(const Location &location,+
−
                                       const QString &filePath)+
−
{+
−
    QFile file(filePath);+
−
    if (!file.open(QFile::ReadOnly))+
−
        return;+
−
+
−
    QString text = file.readAll();+
−
    text.remove("\r");+
−
    text.replace("\\\n", "");+
−
    QStringList lines = text.split("\n");+
−
    lines = lines.filter("Q_DECLARE");+
−
    lines.replaceInStrings(QRegExp("#define Q[A-Z_]*\\(C\\)"), "");+
−
+
−
    if (lines.size() == 4) {+
−
        sequentialIteratorDefinition = lines[0];+
−
        mutableSequentialIteratorDefinition = lines[1];+
−
        associativeIteratorDefinition = lines[2];+
−
        mutableAssociativeIteratorDefinition = lines[3];+
−
    }+
−
    else {+
−
        location.warning(tr("The qiterator.h hack failed"));+
−
    }+
−
}+
−
+
−
void CppCodeParser::instantiateIteratorMacro(const QString &container,+
−
                                             const QString &includeFile,+
−
                                             const QString &macroDef,+
−
                                             Tree * /* tree */)+
−
{+
−
    QString resultingCode = macroDef;+
−
    resultingCode.replace(QRegExp("\\bC\\b"), container);+
−
    resultingCode.replace(QRegExp("\\s*##\\s*"), "");+
−
+
−
    Location loc(includeFile);   // hack to get the include file for free+
−
    QByteArray latin1 = resultingCode.toLatin1();+
−
    Tokenizer stringTokenizer(loc, latin1);+
−
    tokenizer = &stringTokenizer;+
−
    readToken();+
−
    matchDeclList(tre->root());+
−
}+
−
+
−
void CppCodeParser::createExampleFileNodes(FakeNode *fake)+
−
{+
−
    QString examplePath = fake->name();+
−
+
−
    // 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(+
−
               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);+
−
        i.toBack();+
−
        while (i.hasPrevious()) {+
−
            QString fileName = i.previous();+
−
            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");+
−
    }+
−
+
−
    foreach (const QString &exampleFile, exampleFiles)+
−
        (void) new FakeNode(fake,+
−
                            exampleFile.mid(sizeOfBoringPartOfName),+
−
                            Node::File);+
−
    foreach (const QString &imageFile, imageFiles) {+
−
        new FakeNode(fake,+
−
                     imageFile.mid(sizeOfBoringPartOfName),+
−
                     Node::Image);+
−
    }+
−
}+
−
+
−
QT_END_NAMESPACE+
−