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

**

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

**

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

/*

  cppcodemarker.cpp

*/

#include <qdebug.h>

#include "atom.h"

#include "cppcodemarker.h"

#include "node.h"

#include "text.h"

#include "tree.h"

QT_BEGIN_NAMESPACE

static int insertTagAround(QString &result, int pos, int len, const QString &tagName,

                           const QString &attributes = QString())

{

    QString s;

    //s.reserve(result.size() + tagName.size() * 2 + attributes.size() + 20);

    s += result.midRef(0, pos);

    s += QLatin1Char('<');

    s += tagName;

    if (!attributes.isEmpty()) {

        s += QLatin1Char(' ');

        s += attributes;

    }

    s += QLatin1Char('>');

    s += result.midRef(pos, len);

    s += QLatin1String("</");

    s += tagName;

    s += QLatin1Char('>');

    s += result.midRef(pos + len);

    int diff = s.length() - result.length();

    result = s;

    return diff;

}

/*!

  The constructor does nothing.

 */

CppCodeMarker::CppCodeMarker()

{

    // nothing.

}

/*!

  The destructor does nothing.

 */

CppCodeMarker::~CppCodeMarker()

{

    // nothing.

}

/*!

  Returns true.

 */

bool CppCodeMarker::recognizeCode(const QString & /* code */)

{

    return true;

}

/*!

  Returns true if \a ext is any of a list of file extensions

  for the C++ language.

 */

bool CppCodeMarker::recognizeExtension(const QString& ext)

{

    return ext == "c" ||

        ext == "c++" ||

        ext == "cc" ||

        ext == "cpp" ||

        ext == "cxx" ||

        ext == "ch" ||

        ext == "h" ||

        ext == "h++" ||

        ext == "hh" ||

        ext == "hpp" ||

        ext == "hxx";

}

/*!

  Returns true if \a lang is either "C" or "Cpp".

 */

bool CppCodeMarker::recognizeLanguage(const QString &lang)

{

    return lang == "C" || lang == "Cpp";

}

/*!

  Returns the \a node name, or "()" if \a node is a

  Node::Function node.

 */

QString CppCodeMarker::plainName(const Node *node)

{

    QString name = node->name();

    if (node->type() == Node::Function)

	name += "()";

    return name;

}

QString CppCodeMarker::plainFullName(const Node *node, const Node *relative)

{

    if (node->name().isEmpty()) {

	return "global";

    }

    else {

	QString fullName;

	for (;;) {

	    fullName.prepend(plainName(node));

	    if (node->parent() == relative || node->parent()->name().isEmpty())

		break;

	    fullName.prepend("::");

	    node = node->parent();

        }

        return fullName;

    }

}

QString CppCodeMarker::markedUpCode(const QString &code,

                                    const Node *relative,

				    const QString &dirPath)

{

    return addMarkUp(protect(code), relative, dirPath);

}

QString CppCodeMarker::markedUpSynopsis(const Node *node,

                                        const Node * /* relative */,

					SynopsisStyle style)

{

    const int MaxEnumValues = 6;

    const FunctionNode *func;

    const PropertyNode *property;

    const VariableNode *variable;

    const EnumNode *enume;

    const TypedefNode *typedeff;

    QString synopsis;

    QString extra;

    QString name;

    name = taggedNode(node);

    if (style != Detailed)

	name = linkTag(node, name);

    name = "<@name>" + name + "</@name>";

    if (style == Detailed && !node->parent()->name().isEmpty() &&

        node->type() != Node::Property)

	name.prepend(taggedNode(node->parent()) + "::");

    switch (node->type()) {

    case Node::Namespace:

	synopsis = "namespace " + name;

	break;

    case Node::Class:

	synopsis = "class " + name;

	break;

    case Node::Function:

	func = (const FunctionNode *) node;

	if (style != SeparateList && !func->returnType().isEmpty())

	    synopsis = typified(func->returnType()) + " ";

	synopsis += name;

        if (func->metaness() != FunctionNode::MacroWithoutParams) {

            synopsis += " (";

	    if (!func->parameters().isEmpty()) {

	        synopsis += " ";

	        QList<Parameter>::ConstIterator p = func->parameters().begin();

	        while (p != func->parameters().end()) {

		    if (p != func->parameters().begin())

		        synopsis += ", ";

		    synopsis += typified((*p).leftType());

                    if (style != SeparateList && !(*p).name().isEmpty())

                        synopsis +=

                            " <@param>" + protect((*p).name()) + "</@param>";

                    synopsis += protect((*p).rightType());

		    if (style != SeparateList && !(*p).defaultValue().isEmpty())

		        synopsis += " = " + protect((*p).defaultValue());

		    ++p;

	        }

	        synopsis += " ";

	    }

	    synopsis += ")";

        }

	if (func->isConst())

	    synopsis += " const";

	if (style == Summary || style == Accessors) {

	    if (func->virtualness() != FunctionNode::NonVirtual)

		synopsis.prepend("virtual ");

	    if (func->virtualness() == FunctionNode::PureVirtual)

		synopsis.append(" = 0");

	}

        else if (style == SeparateList) {

            if (!func->returnType().isEmpty() && func->returnType() != "void")

                synopsis += " : " + typified(func->returnType());

        }

        else {

	    QStringList bracketed;

	    if (func->isStatic()) {

		bracketed += "static";

	    }

            else if (func->virtualness() != FunctionNode::NonVirtual) {

		if (func->virtualness() == FunctionNode::PureVirtual)

		    bracketed += "pure";

		bracketed += "virtual";

	    }

	    if (func->access() == Node::Protected) {

		bracketed += "protected";

	    }

            else if (func->access() == Node::Private) {

		bracketed += "private";

	    }

	    if (func->metaness() == FunctionNode::Signal) {

		bracketed += "signal";

	    }

            else if (func->metaness() == FunctionNode::Slot) {

		bracketed += "slot";

	    }

	    if (!bracketed.isEmpty())

		extra += " [" + bracketed.join(" ") + "]";

	}

	break;

    case Node::Enum:

	enume = static_cast<const EnumNode *>(node);

	synopsis = "enum " + name;

        if (style == Summary) {

            synopsis += " { ";

            QStringList documentedItems = enume->doc().enumItemNames();

            if (documentedItems.isEmpty()) {

                foreach (const EnumItem &item, enume->items())

                    documentedItems << item.name();

            }

            QStringList omitItems = enume->doc().omitEnumItemNames();

            foreach (const QString &item, omitItems)

                documentedItems.removeAll(item);

            if (documentedItems.size() <= MaxEnumValues) {

                for (int i = 0; i < documentedItems.size(); ++i) {

	            if (i != 0)

		        synopsis += ", ";

		    synopsis += documentedItems.at(i);

                }

            }

            else {

                for (int i = 0; i < documentedItems.size(); ++i) {

		    if (i < MaxEnumValues-2 || i == documentedItems.size()-1) {

	                if (i != 0)

		            synopsis += ", ";

		        synopsis += documentedItems.at(i);

		    }

                    else if (i == MaxEnumValues - 1) {

		        synopsis += ", ...";

		    }

                }

            }

	    if (!documentedItems.isEmpty())

		synopsis += " ";

	    synopsis += "}";

	}

	break;

    case Node::Typedef:

        typedeff = static_cast<const TypedefNode *>(node);

        if (typedeff->associatedEnum()) {

            synopsis = "flags " + name;

        }

        else {

            synopsis = "typedef " + name;

        }

	break;

    case Node::Property:

	property = static_cast<const PropertyNode *>(node);

	synopsis = name + " : " + typified(property->qualifiedDataType());

	break;

    case Node::Variable:

	variable = static_cast<const VariableNode *>(node);

        if (style == SeparateList) {

            synopsis = name + " : " + typified(variable->dataType());

        }

        else {

            synopsis = typified(variable->leftType()) + " " +

                name + protect(variable->rightType());

        }

	break;

    default:

	synopsis = name;

    }

    if (style == Summary) {

	if (node->status() == Node::Preliminary) {

	    extra += " (preliminary)";

	}

        else if (node->status() == Node::Deprecated) {

	    extra += " (deprecated)";

	}

        else if (node->status() == Node::Obsolete) {

	    extra += " (obsolete)";

	}

    }

    if (!extra.isEmpty()) {

	extra.prepend("<@extra>");

	extra.append("</@extra>");

    }

    return synopsis + extra;

}

#ifdef QDOC_QML

/*!

 */

QString CppCodeMarker::markedUpQmlItem(const Node* node, bool summary)

{

    QString name = taggedQmlNode(node);

    if (summary) {

	name = linkTag(node,name);

    }

    name = "<@name>" + name + "</@name>";

    QString synopsis = name;

    if (node->type() == Node::QmlProperty) {

        const QmlPropertyNode* pn = static_cast<const QmlPropertyNode*>(node);

        synopsis += " : " + typified(pn->dataType());

    }

    QString extra;

    if (summary) {

	if (node->status() == Node::Preliminary) {

	    extra += " (preliminary)";

	}

        else if (node->status() == Node::Deprecated) {

	    extra += " (deprecated)";

	}

        else if (node->status() == Node::Obsolete) {

	    extra += " (obsolete)";

	}

    }

    if (!extra.isEmpty()) {

	extra.prepend("<@extra>");

	extra.append("</@extra>");

    }

    return synopsis + extra;

}

#endif

QString CppCodeMarker::markedUpName(const Node *node)

{

    QString name = linkTag(node, taggedNode(node));

    if (node->type() == Node::Function)

	name += "()";

    return name;

}

QString CppCodeMarker::markedUpFullName(const Node *node, const Node *relative)

{

    if (node->name().isEmpty()) {

	return "global";

    }

    else {

	QString fullName;

	for (;;) {

	    fullName.prepend(markedUpName(node));

	    if (node->parent() == relative || node->parent()->name().isEmpty())

		break;

	    fullName.prepend("<@op>::</@op>");

	    node = node->parent();

        }

        return fullName;

    }

}

QString CppCodeMarker::markedUpEnumValue(const QString &enumValue,

                                         const Node *relative)

{

    const Node *node = relative->parent();

    QString fullName;

    while (node->parent()) {

	fullName.prepend(markedUpName(node));

	if (node->parent() == relative || node->parent()->name().isEmpty())

	    break;

	fullName.prepend("<@op>::</@op>");

	node = node->parent();

    }

    if (!fullName.isEmpty())

        fullName.append("<@op>::</@op>");

    fullName.append(enumValue);

    return fullName;

}

QString CppCodeMarker::markedUpIncludes(const QStringList& includes)

{

    QString code;

    QStringList::ConstIterator inc = includes.begin();

    while (inc != includes.end()) {

	code += "#include &lt;<@headerfile>" + *inc + "</@headerfile>&gt;\n";

	++inc;

    }

    return addMarkUp(code, 0, "");

}

QString CppCodeMarker::functionBeginRegExp(const QString& funcName)

{

    return "^" + QRegExp::escape(funcName) + "$";

}

QString CppCodeMarker::functionEndRegExp(const QString& /* funcName */)

{

    return "^\\}$";

}

#if 0

	    FastSection privateReimpFuncs(classe,

                                          "Private Reimplemented Functions",

                                          "private reimplemented function",

                                          "private reimplemented functions");

	    FastSection protectedReimpFuncs(classe,

                                            "Protected Reimplemented Functions",

                                            "protected reimplemented function",

                                            "protected reimplemented functions");

	    FastSection publicReimpFuncs(classe,

                                         "Public Reimplemented Functions",

                                         "public reimplemented function",

                                         "public reimplemented functions");

#endif

QList<Section> CppCodeMarker::sections(const InnerNode *inner,

                                       SynopsisStyle style,

                                       Status status)

{

    QList<Section> sections;

    if (inner->type() == Node::Class) {

        const ClassNode *classe = static_cast<const ClassNode *>(inner);

        if (style == Summary) {

	    FastSection privateFunctions(classe,

                                         "Private Functions",

                                         "private function",

				         "private functions");

	    FastSection privateSlots(classe, "Private Slots", "private slot", "private slots");

	    FastSection privateTypes(classe, "Private Types", "private type", "private types");

	    FastSection protectedFunctions(classe,

                                           "Protected Functions",

                                           "protected function",

				           "protected functions");

	    FastSection protectedSlots(classe,

                                       "Protected Slots",

                                       "protected slot",

                                       "protected slots");

	    FastSection protectedTypes(classe,

                                       "Protected Types",

                                       "protected type",

                                       "protected types");

	    FastSection protectedVariables(classe,

                                           "Protected Variables",

                                           "protected type",

                                           "protected variables");

	    FastSection publicFunctions(classe,

                                        "Public Functions",

                                        "public function",

                                        "public functions");

	    FastSection publicSignals(classe, "Signals", "signal", "signals");

	    FastSection publicSlots(classe, "Public Slots", "public slot", "public slots");

	    FastSection publicTypes(classe, "Public Types", "public type", "public types");

	    FastSection publicVariables(classe,

                                        "Public Variables",

                                        "public type",

                                        "public variables");

	    FastSection properties(classe, "Properties", "property", "properties");

	    FastSection relatedNonMembers(classe,

                                          "Related Non-Members",

                                          "related non-member",

                                          "related non-members");

	    FastSection staticPrivateMembers(classe,

                                             "Static Private Members",

                                             "static private member",

					     "static private members");

	    FastSection staticProtectedMembers(classe,

                                               "Static Protected Members",

					       "static protected member",

                                               "static protected members");