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

**

** Copyright (C) 2009 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_QMLMETHOD               Doc::alias("qmlmethod")

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

{

}

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";

}

void CppCodeParser::terminateParser()

{

    nodeTypeMap.clear();

    CodeParser::terminateParser();

}

QString CppCodeParser::language()

{

    return "Cpp";

}

QString CppCodeParser::headerFileNameFilter()

{

    return "*.ch *.h *.h++ *.hh *.hpp *.hxx";

}

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

}

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

}

void CppCodeParser::doneParsingSourceFiles(Tree *tree)

{

    tree->root()->makeUndocumentedChildrenInternal();

    tree->root()->normalizeOverloads();

    tree->fixInheritance();

    tree->resolveProperties();

}

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