/****************************************************************************

**

** 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 <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)

{

        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());

    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)

{

        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();

}

/*!

  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