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

**

** 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 Qt Mobility Components.

**

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

**

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

#include "parsemanager.h"

#include "cplusplus/CppDocument.h"

#include "./parser/src/shared/cplusplus/Control.h"

#include "TranslationUnit.h"

#include "AST.h"

#include "Symbols.h"

#include <QDebug>

#include "Name.h"

#include "cpptools/cppmodelmanager.h"

#include <QTextStream>

using namespace CppTools;

using namespace CppTools::Internal;

using namespace CPlusPlus;

//<------------------------------------------------------- Compare function for the internal structures

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

Compares function with function

with return type, function name

and their arguments and arguments

types.

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

bool FUNCTIONITEM::isEqualTo(FUNCTIONITEM *cpfct, bool ignoreName/* = true*/)

{

    if(ignoreName)

        return function->isEqualTo(cpfct->function, true);

    return function->isEqualTo(cpfct->function);

}

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

Compares two property regarding

of their function definition,

type definition, function arguments

and function types.

Q_PROPERTY( ConnectionState state READ state NOTIFY stateChanged);

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

bool PROPERTYITEM::isEqualTo(PROPERTYITEM *cpppt)

{

    QString thistype = this->trlUnit->spell(this->ast->type_token);

    QString cppttype = cpppt->trlUnit->spell(cpppt->ast->type_token);

    if(thistype != cppttype)

        return false;

    QString thistypename = this->trlUnit->spell(this->ast->type_name_token);

    QString cppttypename = cpppt->trlUnit->spell(cpppt->ast->type_name_token);

    if(thistypename != cppttypename)

        return false;

    if(this->readdefined != cpppt->readdefined)

        return false;

    if(this->writedefined != cpppt->writedefined)

        return false;

    if(this->resetdefined != cpppt->resetdefined)

        return false;

    if(this->notifydefined != cpppt->notifydefined)

        return false;

    //check for read function

    if(this->readdefined){

        if(!this->readFct || !cpppt->readFct)

            return false;

        if(!this->readFct->isEqualTo(cpppt->readFct))

            return false;

    }

    //check for write function

    if(this->writedefined){

        if(!this->writeFct || !cpppt->writeFct)

            return false;

        if(!this->writeFct->isEqualTo(cpppt->writeFct))

            return false;

    }

    //check for reset function

    if(this->resetdefined){

        if(!this->resetFct || !cpppt->resetFct)

            return false;

        if(!this->resetFct->isEqualTo(cpppt->resetFct))

            return false;

    }

    //check for notify function

    if(this->notifydefined){

        if(!this->notifyFct || !cpppt->notifyFct)

            return false;

        if(!this->notifyFct->isEqualTo(cpppt->notifyFct))

            return false;

    }

    return true;

}

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

Compares two enums regarding

of their values created by the getEnumValueStringList function.

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

bool QENUMITEM::isEqualTo(QENUMITEM *cpenum)

{

    if(this->values.count() != cpenum->values.count())

        return false;

    foreach(QString str, this->values){

        if(!cpenum->values.contains(str))

            return false;

    }

    return true;

}

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

Compares two flags regarding

of their enum definitions and their

values created by the getEnumValueStringList function.

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

bool QFLAGITEM::isEqualTo(QFLAGITEM *cpflag)

{

    if(this->enumvalues.count() != cpflag->enumvalues.count())

        return false;

    foreach(QString str, this->enumvalues){

        if(!cpflag->enumvalues.contains(str))

            return false;

    }

    return true;

}

ParseManager::ParseManager()

: pCppPreprocessor(0)

{

}

ParseManager::~ParseManager()

{

    if(pCppPreprocessor)

        delete pCppPreprocessor;

    if(::m_resultFile){

        ::m_resultFile->close();

        delete ::m_resultFile;

        ::m_resultFile = 0;

    }

}

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

Function for setting the include

Paths

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

void ParseManager::setIncludePath(const QStringList &includePath)

{

    m_includePaths = includePath;

}

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

public Function that starts the parsing

all of the files in the sourceFiles

string list.

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

void ParseManager::parse(const QStringList &sourceFiles)

{

    m_errormsgs.clear();

    if(pCppPreprocessor){

        delete pCppPreprocessor;

        pCppPreprocessor = 0;

    }

    if (! sourceFiles.isEmpty()) {

        m_strHeaderFile = sourceFiles[0];

        pCppPreprocessor = new CppTools::Internal::CppPreprocessor(QPointer<CPlusPlus::ParseManager>(this));

        pCppPreprocessor->setIncludePaths(m_includePaths);

        pCppPreprocessor->setFrameworkPaths(m_frameworkPaths);

        parse(pCppPreprocessor, sourceFiles);

    }

}

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

private function that prepare the filelist

to parse and starts the parser.

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

void ParseManager::parse(CppTools::Internal::CppPreprocessor *preproc,

                            const QStringList &files)

{

    if (files.isEmpty())

        return;

    //check if file is C++ header file

    QStringList headers;

    foreach (const QString &file, files) {

        const QFileInfo fileInfo(file);

        QString ext = fileInfo.suffix();

        if (ext.toLower() == "h")

            headers.append(file);

    }

    foreach (const QString &file, files) {

        preproc->snapshot.remove(file);

    }

    preproc->setTodo(headers);

    QString conf = QLatin1String("<configuration>");

    preproc->run(conf);

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

        QString fileName = headers.at(i);

        preproc->run(fileName);

    }

}

//This function creates a class list for each class and its base classes in

//the header file that needs to be checked.

//e.g.

//      Cl1          Cl2

//     __|__        __|__

//    |     |      |     |

//   Cl11  Cl12   Cl21  Cl22

//

//==> list[0] = {Cl1, Cl11, Cl12}

//    list[1] = {Cl2, Cl21, Cl22}

QList<CLASSTREE*> ParseManager::CreateClassLists(bool isInterfaceHeader)

{

    QList<CLASSTREE*>ret;

    QList<CLASSLISTITEM*> classlist;

    QList<CLASSLISTITEM*> allclasslist;

    Trace("Following classes scaned for header file: " + m_strHeaderFile);

    //Iteration over all parsed documents

    if(getPreProcessor()){

        for (Snapshot::const_iterator it = getPreProcessor()->snapshot.begin()

            ; it != getPreProcessor()->snapshot.end(); ++it)

        {

            Document::Ptr doc = (*it);

            if(doc){

                QFileInfo fileinf(doc->fileName());

                QFileInfo fileinf1(m_strHeaderFile);

                //Get the Translated unit

                Control* ctrl = doc->control();

                TranslationUnit* trlUnit = ctrl->translationUnit();

                AST* pAst = trlUnit->ast();

                TranslationUnitAST *ptrAst = 0;

                if(pAst && (ptrAst = pAst->asTranslationUnit())){

                    //iteration over all translated declaration in this document

                    for (DeclarationListAST *pDecllist = ptrAst->declaration_list; pDecllist; pDecllist = pDecllist->next) {

                        if(pDecllist->value){

                            SimpleDeclarationAST *pSimpleDec = pDecllist->value->asSimpleDeclaration();

                            if(pSimpleDec){

                                //Iteration over class specifier

                                for (SpecifierListAST *pSimpleDecDecllist = pSimpleDec->decl_specifier_list; pSimpleDecDecllist; pSimpleDecDecllist = pSimpleDecDecllist->next) {

                                    ClassSpecifierAST * pclassspec = pSimpleDecDecllist->value->asClassSpecifier();

                                    if(pclassspec){

                                        CLASSLISTITEM* item = new CLASSLISTITEM();

                                        item->classspec = pclassspec;

                                        item->trlUnit = trlUnit;

                                        allclasslist.push_back(item);

                                        QString classname = item->trlUnit->spell(item->classspec->name->firstToken());

                                        Trace("- " + classname + " class scaned");

                                        //We found a class that is defined in the header file that needs to be checked

                                        if(fileinf.fileName().toLower() == fileinf1.fileName().toLower()){

                                            CLASSTREE* cltree = new CLASSTREE();

                                            cltree->highestlevelclass = item;

                                            cltree->classlist.push_back(item);

                                            ret.push_back(cltree);

                                        }

                                    }

                                }

                            }

                        }

                    }

                }

            }

        }

    }

    //after we search for the classes we need to search for the baseclasses

    Trace("Following classes found in Header file: " + m_strHeaderFile);

    foreach(CLASSTREE *cltree, ret){

        QString classname = cltree->highestlevelclass->trlUnit->spell(cltree->highestlevelclass->classspec->name->firstToken());

        Trace("- " + classname + " class found");

        QList<CLASSLISTITEM*> baseclasslist;

        getBaseClasses(cltree->highestlevelclass, baseclasslist, allclasslist, 0, isInterfaceHeader);

        cltree->classlist.append(baseclasslist);

    }

    return ret;

}

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

Gets all the baseclass from a class and 

add those base classes into the baseclasslist

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

void ParseManager::getBaseClasses(const CLASSLISTITEM* pclass

                                  , QList<CLASSLISTITEM*> &baseclasslist

                                  , const QList<CLASSLISTITEM*> &allclasslist

                                  , int level

                                  , bool isInterfaceHeader)

{

    //iteration over the base_clause_list of the current class

    QString levelmarker = "  ";

    for(int i = 0; i < level; i++)

        levelmarker += "   ";

    levelmarker += "|- ";

    QList<CLASSLISTITEM*>child;

    for(BaseSpecifierListAST *pBaseSpecList = pclass->classspec->base_clause_list; pBaseSpecList; pBaseSpecList = pBaseSpecList->next)

    {

        BaseSpecifierAST *pBaseSpec = pBaseSpecList->value;

        bool found = false;

        foreach(CLASSLISTITEM* pclspec, allclasslist)

        {

            if(pclspec->classspec->symbol->name() 

                && pBaseSpec->symbol->name() 

                && pclspec->classspec->symbol->name()->isEqualTo(pBaseSpec->symbol->name()))

            {

                child.push_back(pclspec);

                baseclasslist.push_back(pclspec);

                QString classname = pclspec->trlUnit->spell(pclspec->classspec->name->firstToken());

                Trace(levelmarker + classname + " class found");

                found = true;

                break;

            }

        }

        if(!found && pBaseSpec->name){

            QString classname = pclass->trlUnit->spell(pBaseSpec->name->firstToken());

            if(isInterfaceHeader)

                Trace(levelmarker + classname + " class not found! Interface classes should not be inherited from Qt Objects!");

            else

                Trace(levelmarker + classname + " class not found!");

        }

    }

    //call the function recursive because all the basclasses can have other base classes

    foreach(CLASSLISTITEM* pchclass, child){

        getBaseClasses(pchclass, baseclasslist, allclasslist, ++level, isInterfaceHeader);

    }

}

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

This function finds and creates all Elements wich

are significant for MetaDatas.

Those element will be added in the aparameter 

lists.

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

void ParseManager::getElements(QList<FUNCTIONITEM*> &functionlist

                               , QList<PROPERTYITEM*> &propertylist

                               , QList<QENUMITEM*> &qenumlist

                               , QList<ENUMITEM*> &enumlist

                               , QList<QFLAGITEM*> &qflaglist

                               , QList<QDECLAREFLAGSITEM*> &qdeclareflaglist

                               , const QList<CLASSLISTITEM*> classitems

                               , const CLASSLISTITEM* highestlevelclass)

{

    foreach(CLASSLISTITEM* classitem, classitems){

        QString classname = "";

        if(classitem->classspec->name)

            classname = classitem->trlUnit->spell(classitem->classspec->name->firstToken());

        for (DeclarationListAST *pmemberlist = classitem->classspec->member_specifier_list; pmemberlist; pmemberlist = pmemberlist->next) {

            /**********

            Functions

            **********/

            FunctionDefinitionAST *pfctdef = pmemberlist->value->asFunctionDefinition();

            if(pfctdef){

                FUNCTIONITEM* item = new FUNCTIONITEM();

                item->trlUnit = classitem->trlUnit;

                item->function = pfctdef->symbol;

                item->classAst = classitem->classspec;

                item->highestlevelclass = highestlevelclass;

                functionlist.push_back(item);

                if(isMetaObjFunction(item))

                    Trace("  - " + getTraceFuntionString(item, classname) + " found");

            }

            SimpleDeclarationAST *pdecl = pmemberlist->value->asSimpleDeclaration();

            if(pdecl){

                for(List<Declaration*>* decllist = pdecl->symbols; decllist; decllist = decllist->next)

                {

                    Function* pfct = decllist->value->type()->asFunctionType();

                    if(pfct){

                        FUNCTIONITEM* item = new FUNCTIONITEM();

                        item->trlUnit = classitem->trlUnit;

                        item->function = pfct;

                        item->classAst = classitem->classspec;

                        item->highestlevelclass = highestlevelclass;

                        functionlist.push_back(item);

                        if(isMetaObjFunction(item))

                            Trace("  - " + getTraceFuntionString(item, classname) + " found");

                    }

                }

                /******

                enum

                ******/

                for(List<SpecifierAST*>* decllist = pdecl->decl_specifier_list; decllist; decllist = decllist->next)

                {

                    EnumSpecifierAST * penum = decllist->value->asEnumSpecifier();

                    if(penum){

                        ENUMITEM* item = new ENUMITEM();

                        item->ast = penum;

                        item->highestlevelclass = highestlevelclass;

                        item->trlUnit = classitem->trlUnit;

                        enumlist.push_back(item);

                    }

                }

            }

            else{

                /**********

                Q_PROPERTY

                **********/

                QPropertyDeclarationAST *ppdecl = pmemberlist->value->asQPropertyDeclarationAST();

                if(ppdecl){

                    PROPERTYITEM* item = new PROPERTYITEM();

                    item->ast = ppdecl;

                    item->highestlevelclass = highestlevelclass;

                    item->trlUnit = classitem->trlUnit;

                    item->readdefined = (ppdecl->read_token > 0);

                    item->writedefined = (ppdecl->write_token > 0);

                    item->resetdefined = (ppdecl->reset_token > 0);

                    item->notifydefined = (ppdecl->notify_token > 0);

                    propertylist.push_back(item);

                    if(item->ast->type_name_token > 0){

                        QString propertyname = item->trlUnit->spell(item->ast->type_name_token);

                        Trace("  - Q_PROPERTY: " + classname + "::" + propertyname + " found");

                    }

                }

                else{

                    /**********

                    Q_ENUM

                    **********/

                    QEnumDeclarationAST *pqenum = pmemberlist->value->asQEnumDeclarationAST();

                    if(pqenum){

                        if(pqenum->enumerator_list){

                            for (EnumeratorListAST *plist = pqenum->enumerator_list; plist; plist = plist->next) {

                                QENUMITEM* item = new QENUMITEM();

                                item->ast = plist->value;

                                item->highestlevelclass = highestlevelclass;

                                item->trlUnit = classitem->trlUnit;

                                qenumlist.push_back(item);

                                QString enumname = item->trlUnit->spell(item->ast->firstToken());

                                Trace("  - Q_ENUM: " + classname + "::" + enumname + " found");

                            }

                        }

                    }

                    else{

                        /**********

                        Q_FLAGS

                        **********/

                        QFlagsDeclarationAST *pqflags = pmemberlist->value->asQFlagsDeclarationAST();

                        if(pqflags){

                            if(pqflags->enumerator_list){

                                for (EnumeratorListAST *plist = pqflags->enumerator_list; plist; plist = plist->next) {

                                    QFLAGITEM* item = new QFLAGITEM();

                                    item->ast = plist->value;

                                    item->highestlevelclass = highestlevelclass;

                                    item->trlUnit = classitem->trlUnit;

                                    qflaglist.push_back(item);

                                    QString enumname = item->trlUnit->spell(plist->firstToken());

                                    Trace("  - Q_FLAGS: " + classname + "::" + enumname + " found");

                                }

                            }

                        }

                        else {

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

                            Q_DECLARE_FLAGS

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

                            QDeclareFlagsDeclarationAST *pqdeclflags = pmemberlist->value->asQDeclareFlagsDeclarationAST();

                            if(pqdeclflags){

                                QDECLAREFLAGSITEM* item = new QDECLAREFLAGSITEM();

                                item->ast = pqdeclflags;

                                item->highestlevelclass = highestlevelclass;

                                item->trlUnit = classitem->trlUnit;

                                qdeclareflaglist.push_back(item);

                            }

                        }

                    }

                }

            }

        }

    }

}

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

Function that starts the comare between the 

parser result and their metadata content.

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

bool ParseManager::checkAllMetadatas(ParseManager* pInterfaceParserManager, QString resultfile)

{

    bool ret = true;

    //Create output file

    if(!resultfile.isEmpty() && ::m_resultFile == 0){

        ::m_resultFile = new QFile(resultfile);

        if (!::m_resultFile->open(QFile::WriteOnly | QFile::Truncate)) {

            delete ::m_resultFile;

            ::m_resultFile = 0;