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

**

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

**

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

/*

  qscodeparser.cpp

*/

#include <qfile.h>

#include <qregexp.h>

#include "config.h"

#include "qscodeparser.h"

#include "text.h"

#include "tokenizer.h"

#include "tree.h"

QT_BEGIN_NAMESPACE

#define CONFIG_QUICK                    "quick"

#define CONFIG_REPLACES                 "replaces"

#define COMMAND_BRIEF                   Doc::alias( "brief")

#define COMMAND_CODE                    Doc::alias( "code")

#define COMMAND_ENDCODE                 Doc::alias( "endcode")

#define COMMAND_ENDQUICKCODE            Doc::alias( "endquickcode")

#define COMMAND_FILE                    Doc::alias( "file")

#define COMMAND_GROUP                   Doc::alias( "group")

#define COMMAND_MODULE                  Doc::alias( "module")

#define COMMAND_PAGE                    Doc::alias( "page")

#define COMMAND_QUICKCLASS              Doc::alias( "quickclass")

#define COMMAND_QUICKCODE               Doc::alias( "quickcode")

#define COMMAND_QUICKENUM               Doc::alias( "quickenum")

#define COMMAND_QUICKFN                 Doc::alias( "quickfn")

#define COMMAND_QUICKIFY                Doc::alias( "quickify")

#define COMMAND_QUICKPROPERTY           Doc::alias( "quickproperty")

#define COMMAND_PROTECTED               Doc::alias( "protected")

#define COMMAND_REPLACE                 Doc::alias( "replace")

static QString balancedParens = "(?:[^()]+|\\([^()]*\\))*";

QsCodeParser::QsCodeParser(Tree *cppTree)

    : cppTre(cppTree), qsTre(0), replaceRegExp("/(.+)/([^/]*)/")

{

}

QsCodeParser::~QsCodeParser()

{

}

void QsCodeParser::initializeParser(const Config& config)

{

    CppCodeParser::initializeParser(config);

    nodeTypeMap.insert(COMMAND_QUICKCLASS, Node::Class);

    nodeTypeMap.insert(COMMAND_QUICKENUM, Node::Enum);

    nodeTypeMap.insert(COMMAND_QUICKPROPERTY, Node::Property);

    nodeTypeMap.insert(COMMAND_QUICKFN, Node::Function);

    QString quickDotReplaces = CONFIG_QUICK + Config::dot + CONFIG_REPLACES;

    QStringList replaces = config.getStringList(quickDotReplaces);

    QStringList::ConstIterator r = replaces.begin();

    while (r != replaces.end()) {

	if (replaceRegExp.exactMatch(*r)) {

	    QRegExp before(replaceRegExp.cap(1));

	    before.setMinimal(true);

	    QString after = replaceRegExp.cap(2);

	    if (before.isValid()) {

		replaceBefores << before;

		replaceAfters << after;

	    }

            else {

		config.lastLocation().warning(

			tr("Invalid regular expression '%1'")

			.arg(before.pattern()));

	    }

	}

        else {

	    config.lastLocation().warning(tr("Bad syntax in '%1'")

					   .arg(quickDotReplaces));

	}

	++r;

    }

}

void QsCodeParser::terminateParser()

{

    nodeTypeMap.clear();

    classesWithNoQuickDoc.clear();

    replaceBefores.clear();

    replaceAfters.clear();

    CppCodeParser::terminateParser();

}

QString QsCodeParser::language()

{

    return "Qt Script";

}

QString QsCodeParser::headerFileNameFilter()

{

    return "*";

}

QString QsCodeParser::sourceFileNameFilter()

{

    return "*.qs *.qsd";

}

void QsCodeParser::parseHeaderFile(const Location& location,

                                   const QString& filePath,

                                   Tree *tree)

{

    qsTre = tree;

	location.error(tr("Cannot open Qt Script class list '%1'")

			.arg(filePath));

	return;

    }

    Location fileLocation(filePath);

    Tokenizer fileTokenizer(fileLocation, in);

    int tok = fileTokenizer.getToken();

    while (tok != Tok_Eoi) {

	if (tok == Tok_Ident) {

	    ClassNode *quickClass = new ClassNode(qsTre->root(),

						   fileTokenizer.lexeme());

	    quickClass->setLocation(fileTokenizer.location());

	}

        else {

	    fileTokenizer.location().error(tr("Unexpected token '%1' in Qt"

					       " Script class list")

					    .arg(fileTokenizer.lexeme()));

	    break;

	}

	tok = fileTokenizer.getToken();

    }

}

void QsCodeParser::parseSourceFile(const Location& location,

                                   const QString& filePath,

                                   Tree *tree)

{

    qsTre = tree;

    CppCodeParser::parseSourceFile(location, filePath, tree);

}

void QsCodeParser::doneParsingHeaderFiles(Tree *tree)

{

    NodeList::ConstIterator c = tree->root()->childNodes().begin();

    while (c != tree->root()->childNodes().end()) {

	if ((*c)->type() == Node::Class)

	    quickifyClass((ClassNode *) *c);

	++c;

    }

    cppTre->root()->deleteChildren(); // save memory

    tree->resolveInheritance();

    tree->resolveProperties();

}

void QsCodeParser::doneParsingSourceFiles(Tree *tree)

{

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

    NodeList::ConstIterator c = tree->root()->childNodes().begin();

    while (c != tree->root()->childNodes().end()) {

	if ((*c)->type() == Node::Class) {

	    QMap<QString, Node *>::ConstIterator cwnqd =

		    classesWithNoQuickDoc.find((*c)->name());

	    if (cwnqd != classesWithNoQuickDoc.end()) {

		(*cwnqd)->location().warning(tr("No '\\%1' documentation for"

						 " class '%2'")

					      .arg(COMMAND_QUICKCLASS)

					      .arg(cwnqd.key()));

		(*cwnqd)->setDoc(Doc(), true);

	    }

	}

	++c;

    }

    // ### check which enum types are used

}

FunctionNode *QsCodeParser::findFunctionNode(const QString& synopsis,

					      Tree *tree)

{

    QStringList parentPath;

    FunctionNode *clone;

    FunctionNode *func = 0;

    if (makeFunctionNode(synopsis, &parentPath, &clone)) {

	func = tree->findFunctionNode(parentPath, clone);

	delete clone;

    }

    return func;

}

QSet<QString> QsCodeParser::topicCommands()

{

    return QSet<QString>() << COMMAND_FILE << COMMAND_GROUP << COMMAND_MODULE

			   << COMMAND_PAGE << COMMAND_QUICKCLASS

			   << COMMAND_QUICKENUM << COMMAND_QUICKFN

			   << COMMAND_QUICKPROPERTY;

}

Node *QsCodeParser::processTopicCommand(const Doc& doc,

                                        const QString& command,

                                        const QString& arg)

{

    if (command == COMMAND_QUICKFN) {

	QStringList parentPath;

	FunctionNode *quickFunc = 0;

	FunctionNode *clone;

	if (makeFunctionNode(arg, &parentPath, &clone)) {

	    FunctionNode *kernelFunc = findKernelFunction(parentPath,

							   clone->name());

	    if (kernelFunc != 0)

		kernelFunc->setAccess(Node::Private);

	    quickFunc = qsTre->findFunctionNode(parentPath, clone);

	    if (quickFunc == 0 && kernelFunc != 0) {

		quickFunc = new FunctionNode(kernelFunc->parent(),

					      kernelFunc->name());

		quickFunc->setLocation(kernelFunc->location());

		quickFunc->setReturnType(clone->returnType());

		quickFunc->setParameters(clone->parameters());

	    }

	    if (quickFunc == 0) {

		doc.location().warning(tr("Cannot find '%1' specified with '\\%2'")

					.arg(arg).arg(command));

	    }

            else {

		quickFunc->setAccess(Node::Public);

		QStringList qtParams = quickFunc->parameterNames();

		quickFunc->borrowParameterNames(clone);

		QStringList quickParams = quickFunc->parameterNames();

		setQuickDoc(quickFunc, doc, qtParams, quickParams);

	    }

	    delete clone;

	}

        else {

	    doc.location().warning(tr("Cannot find '%1' specified with '\\%2'")

				    .arg(arg).arg(command));

	}

	return 0;

    }

    else if (nodeTypeMap.contains(command)) {

	QStringList subArgs = arg.split(" ");

	QString dataType;

	if (subArgs.count() == 3 && subArgs[1] == ":") {

	    dataType = subArgs[2];

	}

        else if (subArgs.count() != 1) {

	    doc.location().warning(tr("Invalid syntax in '\\%1'")

				    .arg(command));

	}

	QStringList path = subArgs[0].split(".");

	Node *quickNode = qsTre->findNode(path, nodeTypeMap[command]);

	if (quickNode == 0) {

	    doc.location().warning(tr("Cannot find '%1' specified with '\\%2'")

				    .arg(arg).arg(command));

	}

        else {

	    setQuickDoc(quickNode, doc);

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

		classesWithNoQuickDoc.remove(quickNode->name());

		if (doc.briefText().isEmpty())

		    doc.location().warning(tr("Missing '\\%1' for class '%2'")

					    .arg(COMMAND_BRIEF)

					    .arg(quickNode->name()));

	    }

            else if (quickNode->type() == Node::Property) {

		PropertyNode *quickProperty = (PropertyNode *) quickNode;

		if (quickProperty->dataType() == "Object") {

		    if (dataType.isEmpty()) {

			doc.location().warning(tr("Missing data type in '\\%1'"

						   " (assuming 'Object')")

						.arg(command));

		    }

                    else {

			quickProperty->setDataType(dataType);

		    }

		}

                else if (dataType != quickProperty->dataType()) {

		    doc.location().warning(tr("Ignored contradictory data type"

					       " in '\\%1'")

					    .arg(command));

		}

	    }

	}

	return 0;

    }

    else {

	return CppCodeParser::processTopicCommand(doc, command, arg);

    }

}

QSet<QString> QsCodeParser::otherMetaCommands()

{

    return commonMetaCommands() << COMMAND_ENDQUICKCODE << COMMAND_QUICKCODE

				<< COMMAND_QUICKIFY << COMMAND_REPLACE;

}

void QsCodeParser::processOtherMetaCommand(const Doc& doc,

                                           const QString& command,

                                           const QString& arg,

                                           Node *node)

{

    if (command == COMMAND_PROTECTED) {

	doc.location().warning(tr("Cannot use '\\%1' in %2")

				.arg(COMMAND_PROTECTED).arg(language()));

    }

    else {

	CppCodeParser::processOtherMetaCommand(doc,command,arg,node);

    }

}

ClassNode *QsCodeParser::tryClass(const QString& className)

{

    return (ClassNode*) cppTre->findNode(QStringList(className),Node::Class);

}

FunctionNode *QsCodeParser::findKernelFunction(const QStringList& parentPath,

                                               const QString& name)

{

    FunctionNode clone(0, name);

    clone.setReturnType("Object");

    clone.addParameter(Parameter("..."));

    return qsTre->findFunctionNode(parentPath, &clone);

}

void QsCodeParser::extractRegExp(const QRegExp& regExp,

                                 QString& source,

                                 const Doc& doc)

{

    QRegExp blankLineRegExp(

	    "[ \t]*(?:\n(?:[ \t]*\n)+[ \t]*|[ \n\t]*\\\\code|"

	    "\\\\endcode[ \n\t]*)");

    QStringList paras = source.trimmed().split(blankLineRegExp);

    paras = paras.filter(regExp);

    if (paras.count() == 0) {

	doc.location().warning(tr("Cannot find regular expression '%1'")

				.arg(regExp.pattern()));

    }

    else if (paras.count() > 1) {

	doc.location().warning(tr("Regular rexpression '%1' matches multiple"

				   "times").arg(regExp.pattern()));

    }

    else {

	source = paras.first() + "\n\n";

    }

}

void QsCodeParser::extractTarget(const QString& target,

                                 QString& source,

                                 const Doc& doc)

{

    QRegExp targetRegExp(

	    "(\\\\target\\s+(\\S+)[^\n]*\n"

	    "(?:(?!\\s*\\\\code)[^\n]+\n|\\s*\\\\code.*\\\\endcode\\s*\n)*)"

	    "(?:\\s*\n|[^\n]*$)");

    targetRegExp.setMinimal(true);

    int pos = 0;

    while ((pos = source.indexOf(targetRegExp, pos)) != -1) {

	if (targetRegExp.cap(2) == target) {

	    source = targetRegExp.cap(1) + "\n\n";

	    return;

	}

	pos += targetRegExp.matchedLength();

    }

    doc.location().warning(tr("Cannot find target '%1'").arg(target));

}

void QsCodeParser::renameParameters(QString& source,

                                    const Doc& /* doc */,

                                    const QStringList& qtParams,

                                    const QStringList& quickParams)

{

    QRegExp paramRegExp("(\\\\a\\s*\\{?\\s*)([A-Za-z0-9_]+)");

    int pos = 0;

    while ((pos = paramRegExp.indexIn(source, pos)) != -1) {

	pos += paramRegExp.cap(1).length();

	QString before = paramRegExp.cap(2);

	int index = qtParams.indexOf(before);

	if (index != -1) {

	    QString after = quickParams[index];

	    source.replace(pos, before.size(), after);

	}

    }

}

void QsCodeParser::applyReplacementList(QString& source, const Doc& doc)

{

    QStringList args = doc.metaCommandArgs(COMMAND_REPLACE);

    QStringList::ConstIterator a = args.begin();

    while (a != args.end()) {

	if (replaceRegExp.exactMatch(*a)) {

	    QRegExp before(replaceRegExp.cap(1));

	    before.setMinimal(true);

	    QString after = replaceRegExp.cap(2);

	    if (before.isValid()) {

		int oldLen = source.size();

		source.replace(before, after);

		// this condition is sufficient but not necessary

		if (oldLen == source.size() && !source.contains(after))

		    doc.location().warning(

			    tr("Regular expression '%1' did not match anything")

			    .arg(before.pattern()));

	    }

            else {

		doc.location().warning(

			tr("Invalid regular expression '%1'")

			.arg(before.pattern()));

	    }

	}

        else {

	    doc.location().warning(tr("Bad syntax in '\\%1'")

				    .arg(COMMAND_REPLACE));

	}

	++a;

    }

    QRegExp codeRegExp("\\\\" + COMMAND_CODE + "(.*)\\\\" + COMMAND_ENDCODE);

    codeRegExp.setMinimal(true);

    QRegExp quickcodeRegExp(

	    "\\\\" + COMMAND_QUICKCODE + "(.*)\\\\" + COMMAND_ENDQUICKCODE);

    quickcodeRegExp.setMinimal(true);

    int quickcodePos = doc.source().indexOf(quickcodeRegExp);

    if (quickcodePos != -1) {

	int codePos = source.indexOf(codeRegExp);

	if (codePos == -1) {

	    doc.location().warning(

		    tr("Cannot find any '\\%1' snippet corresponding to '\\%2'")

		    .arg(COMMAND_CODE).arg(COMMAND_QUICKCODE));

	}

        else {

	    source.replace(codeRegExp.pos(1), codeRegExp.cap(1).length(),

			    quickcodeRegExp.cap(1));

	    codePos = codeRegExp.pos(1) + quickcodeRegExp.cap(1).length();

	    if (doc.source().indexOf(quickcodeRegExp, quickcodePos + 1) != -1) {

		doc.location().warning(

			tr("Cannot use '\\%1' twice in a row")

			.arg(COMMAND_QUICKCODE));

	    }

            else if (source.indexOf(codeRegExp, codePos + 1) != -1) {

		doc.location().warning(tr("Ambiguous '\\%1'")

					.arg(COMMAND_QUICKCODE));

	    }

	}

    }

}

void QsCodeParser::quickifyClass(ClassNode *quickClass)

{

    QString qtClassName = quickClass->name();

    QString bare = quickClass->name();

    if (bare != "Qt" && bare != "Object") {

	if (bare.startsWith("Q")) {

	    bare = bare.mid(1);

	}

        else {

	    qtClassName.prepend("Q");

	    classesWithNoQ.insert(bare);

	}

    }

    ClassNode *qtClass = 0;

    ClassNode *wrapperClass = 0;

    if ((wrapperClass = tryClass("Quick" + bare)) != 0 ||

	 (wrapperClass = tryClass("QS" + bare + "Class")) != 0) {

	qtClass = tryClass(qtClassName);

	if (qtClass == 0) {

	    qtClass = wrapperClass;

	    wrapperClass = 0;

	}