/*

* Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  

*

*/

#include "CmdGlobals.h"

#ifdef __WIN__

#pragma warning(disable:4786)

#endif

#include <assert.h>

#include <map>

#include <list>

#include <string>

#include <time.h>

#include <xercesc/dom/DOM.hpp>

#include "BBCAnalyser.h"

#include "BBCPreAnalysis.h"

#include "Issues.h"

#include "ReportGenerator.h"

#include "ReportIssue.h"

#include "XMLUtils.h"

#include "XMLStringConst.h"

#include "VariableNodeAnalysis.h"

#include "EnumNodeAnalysis.h"

#include "FunctionNodeAnalysis.h"

#include "TypedefNodeAnalysis.h"

#include "OperatorFunctionNodeAnalysis.h"

#include "UnionNodeAnalysis.h"

#include "ClassNodeAnalysis.h"

#include "StructNodeAnalysis.h"

#include "NodeTypeComparator.h"

#include "Utils.h"

using namespace std;

XERCES_CPP_NAMESPACE_USE

struct ConstructorElement

{

    const XMLCHAR* iEntityName;	

    NodeAnalysis::Constructor iConstructor;

};

// Table of different node analysis constructor functions

const ConstructorElement KConstructorTable[KEntityComparisonTableCount]=

    {

    {KXMLBaseString,UnderConstructionNodeAnalysis::Construct},

    {KXMLFundamentalTypeString,UnderConstructionNodeAnalysis::Construct},

    {KXMLTypedefString,TypedefNodeAnalysis::Construct},//

    {KXMLNamespaceString,UnderConstructionNodeAnalysis::Construct},

    {KXMLCvQualifiedTypeString,UnderConstructionNodeAnalysis::Construct},

    {KXMLVariableString,VariableNodeAnalysis::Construct},//

    {KXMLFundamentalTypeString,UnderConstructionNodeAnalysis::Construct},

    {KXMLTypedefString,UnderConstructionNodeAnalysis::Construct},

    {KXMLNamespaceString,UnderConstructionNodeAnalysis::Construct},

    {KXMLFunctionString,FunctionNodeAnalysis::Construct},//

    {KXMLEnumerationString,EnumNodeAnalysis::Construct},//

    {KXMLFieldString,UnderConstructionNodeAnalysis::Construct},

    {KXMLArgumentString,UnderConstructionNodeAnalysis::Construct},

    {KXMLEllipsisString,UnderConstructionNodeAnalysis::Construct},

    {KXMLArrayTypeString,UnderConstructionNodeAnalysis::Construct},

    {KXMLClassString,ClassNodeAnalysis::Construct},//

    {KXMLConstructorString,UnderConstructionNodeAnalysis::Construct},

    {KXMLConverterString,UnderConstructionNodeAnalysis::Construct},

    {KXMLDestructorString,UnderConstructionNodeAnalysis::Construct},

    {KXMLEnumValueString,UnderConstructionNodeAnalysis::Construct},

    {KXMLFileString,UnderConstructionNodeAnalysis::Construct},

    {KXMLFunctionTypeString,UnderConstructionNodeAnalysis::Construct},

    {KXMLMethodString,UnderConstructionNodeAnalysis::Construct},

    {KXMLMethodTypeString,UnderConstructionNodeAnalysis::Construct},

    {KXMLNamespaceAliasString,UnderConstructionNodeAnalysis::Construct},

    {KXMLOffsetTypeString,UnderConstructionNodeAnalysis::Construct},

    {KXMLOperatorFunctionString,OperatorFunctionNodeAnalysis::Construct},

    {KXMLOperatorMethodString,UnderConstructionNodeAnalysis::Construct},

    {KXMLPointerTypeString,UnderConstructionNodeAnalysis::Construct},

    {KXMLReferenceTypeString,UnderConstructionNodeAnalysis::Construct},

    {KXMLStructString,StructNodeAnalysis::Construct},

    {KXMLUnimplementedString,UnderConstructionNodeAnalysis::Construct},

    {KXMLUnionString,UnionNodeAnalysis::Construct}

    };

// ----------------------------------------------------------------------------

// NodeAnalysis::FindNodeAnalysisConstructor

// ----------------------------------------------------------------------------

//

NodeAnalysis::Constructor FindNodeAnalysisConstructor(const XMLCh* nodeName)

{

    int i = 0;

    for (i = 0;i < KEntityComparisonTableCount; ++i)

    {

        if ( Equals(KConstructorTable[i].iEntityName,nodeName) )

        {

            return KConstructorTable[i].iConstructor;

        }

    }

    return NULL;

}

// ----------------------------------------------------------------------------

// BBCPreAnalysis::preAnalyseClassForVirtuality

// 

// Analyse for virtuality

// ----------------------------------------------------------------------------

//

bool BBCPreAnalysis::preAnalyseClassForVirtuality(HANodeIterator classNode)

{

	bool isvirtual = false;

	bool hasvirtualbases = false;

    //Check to see if we have already inspected this class

    if ( classNode.GetAttribute(KXMLBBCVirtualString) )

    {

        return classNode.CheckForBooleanAttribute(KXMLBBCVirtualString);

    }

    if ( classNode->hasChildNodes() )

    {

        //Check for virtual bases first as it is quicker

        DOMNodeList * childs = classNode->getChildNodes();

        XMLSize_t childcount = childs->getLength();

        for (unsigned int i = 0; i < childcount; ++i)

        {

            DOMNode* child = childs->item(i);

            //Skip any other than Base node

            if ( !Equals(child->getNodeName(),KXMLBaseString) ) 

            {

                continue;

            }

            HANodeIterator childclass(classNode);

            childclass.current = child;

            if ( childclass.CheckForBooleanAttribute(KXMLVirtualString) )

            {

                classNode.SetAttribute(KXMLBBCVirtualInheritanceString,KXML1String);

                hasvirtualbases = true;

            }

            const XMLCh * classid = childclass.GetAttribute(KXMLTypeString);

            assert(classid != NULL);

            bool ret = childclass.FindNodeById(classid);

            assert(ret == true);

            if ( preAnalyseClassForVirtuality( childclass ) )

            {

                //The class is virtual, mark it to the xml document and return

                classNode.SetAttribute(KXMLBBCVirtualString, KXML1String);

                isvirtual = true;

            }

            if ( childclass.CheckForBooleanAttribute(KXMLBBCVirtualInheritanceString) )

            {

                classNode.SetAttribute(KXMLBBCVirtualInheritanceString,KXML1String);

                hasvirtualbases = true;

            }

        }

    }

    //We have already detected that this is virtual class

    if ( isvirtual )

    {

        ClassGenerateVirtualTable(classNode);

        return true;

    }

    //Go through the methods of the class and check them for virtuality

    const XMLCh* attributeValue = classNode.GetAttribute(KXMLMembersString);

    if (attributeValue)

    {

        BaseRefVectorOf< XMLCh > * memberids_ptr = XMLString::tokenizeString(attributeValue);

        auto_ptr<BaseRefVectorOf< XMLCh > > memberids(memberids_ptr);

        for (unsigned int i = 0; i < memberids->size(); ++i)

        {

            const XMLCh * memberid = memberids->elementAt(i);

            HANodeIterator member(classNode);

            bool memberfound = member.FindNodeById(memberid);

            if ( memberfound )

            {

                if ( member.CheckForBooleanAttribute(KXMLVirtualString) ||

                    member.CheckForBooleanAttribute(KXMLPureVirtualString))

                {

                    //Generate primary virtual table for the class

                    ClassGenerateVirtualTable(classNode);

                    //The class is virtual, mark it to the xml document and return

                    classNode.SetAttribute(KXMLBBCVirtualString, KXML1String);

                    return true;

                }

            }

            else

            {

                //The tree is broken

                assert(false);

            }

        }

        //memberids->cleanup();

        //delete memberids;

    }

    classNode.SetAttribute(KXMLBBCVirtualString, KXML0String);

    return false;

}

// ----------------------------------------------------------------------------

// BBCAnalyser::preAnalyseClassForDerivability

//

// Check for derivability. The class is derivable iff:

// 1. Has a public or protected explicitely declared exported constructor

// 2. Has a public or protected inline constructor

// In GCCXML:

// 

// Check methods of type "Constructor" 

//

// Constructor type / attribute:| artificial | explicit | inline | exported

//--------------------------------------------------------------------------

// implicite inline constructor |     x     |     x     |   x    |          

// inline constructor           |           |    (x)    |   x    |          

// exported constructor         |           |    (x)    |        |    x     

// ----------------------------------------------------------------------------

//

void BBCPreAnalysis::preAnalyseClassForDerivability(HANodeIterator classNode)

{

    //Go through the methods of the class and check them for constructor

    const XMLCh* attributeValue = classNode.GetAttribute(KXMLMembersString);

    //Default to public desctructor as it is same as no desctructor at all

    classNode.SetAttribute(KXMLBBCDestructorAccessString,KXMLBBCAccessPublicString);

    if (attributeValue)

    {

        BaseRefVectorOf< XMLCh > * memberids_ptr = XMLString::tokenizeString (attributeValue);

        auto_ptr<BaseRefVectorOf< XMLCh > > memberids(memberids_ptr);

        for (unsigned int i = 0; i < memberids->size(); ++i)

        {

            const XMLCh * memberid = memberids->elementAt(i);

            HANodeIterator member(classNode);

            if ( member.FindNodeById(memberid) )

            {

                //The member is constructor

                if ( Equals(member->getNodeName(),KXMLConstructorString) )

                {

                    //Check if the constructor is protected or public

                    const XMLCh* accessAttribute = member.GetAttribute(KXMLAccessString);

                    if ( Equals(accessAttribute,KXMLProtectedString) || Equals(accessAttribute,KXMLPublicString) )

                    {

                        //If the constructor is artificial (compiler generated) we need to check for the explicit attribute 

                        // to recognize the proper constructor and not the helper constructor generated by the compiler

                        bool artificial = member.CheckForBooleanAttribute(KXMLArtificialString);

                        bool explicit_val = member.CheckForBooleanAttribute(KXMLExplicitString);

                        bool inline_val = member.CheckForBooleanAttribute(KXMLInlineString);

                        const XMLCh* attributeAttribute = member.GetAttribute(KXMLAttributeString);                            

                        //Check for export or inline

                        if ( ( inline_val && explicit_val && artificial ) || //the constructor is compiler generated inline function

                             ( inline_val && !artificial ) ||  //the constructor is explicitely declared inline function

                             (attributeAttribute && Equals(attributeAttribute,KXMLExportedString))  //the constructor is explicitely declared exported function

                            )

                            {

                                if ( Equals(accessAttribute,KXMLProtectedString) )

                                {

                                    //Is derivable class. Mark the node as one.

                                    classNode.SetAttribute(KXMLBBCProtectedConstructorString,KXML1String);

                                }

                                if ( Equals(accessAttribute,KXMLPublicString) )

                                {

                                    classNode.SetAttribute(KXMLBBCPublicConstructorString,KXML1String);

                                    //Class is instantiable,too!!!

                                }

                            }

                    }

                } else if ( Equals(member->getNodeName(),KXMLDestructorString) )

                {

                    //Check if the destructor is private, protected or public and accessibility

                    // if the desctructor is not accessible it is marked as private 

                    const XMLCh* accessAttribute = member.GetAttribute(KXMLAccessString);

                    bool inline_val = member.CheckForBooleanAttribute(KXMLInlineString);

                    bool virtual_val = member.CheckForBooleanAttribute(KXMLVirtualString) ||

                                        member.CheckForBooleanAttribute(KXMLPureVirtualString);

                    bool exported_val = false; 

                    const XMLCh* attributeAttribute = member.GetAttribute(KXMLAttributeString);                            

                    if (attributeAttribute && Equals(attributeAttribute,KXMLExportedString) )

                    {

                        exported_val = true;

                    }

                    if ( !Equals(accessAttribute,KXMLPrivateString) && (inline_val || virtual_val || exported_val) )

                    {

                        if ( Equals(accessAttribute,KXMLPublicString) )

                        {

                            classNode.SetAttribute(KXMLBBCDestructorAccessString,KXMLBBCAccessPublicString);

                        } else if ( Equals(accessAttribute,KXMLProtectedString) )

                        {

                            classNode.SetAttribute(KXMLBBCDestructorAccessString,KXMLBBCAccessProtectedString);

                        } 

                    }

                    else

                    {

                        classNode.SetAttribute(KXMLBBCDestructorAccessString,KXMLBBCAccessPrivateString);

                    }

                }

            }

            else

            {

                //The tree is broken

                assert(false);

            }

        }

        //delete memberids;

    }

}

// ----------------------------------------------------------------------------

// BBCAnalyser::preAnalyseClassForInlineFunctions

// 

// ----------------------------------------------------------------------------

//

void BBCPreAnalysis::preAnalyseClassForInlineFunctions(HANodeIterator classNode)

{

    //Go through the methods of the class and check them for virtuality

    const XMLCh* attributeValue = classNode.GetAttribute(KXMLMembersString);

    if (attributeValue)

    {

        BaseRefVectorOf< XMLCh > * memberids_ptr = XMLString::tokenizeString (attributeValue);

        auto_ptr<BaseRefVectorOf< XMLCh > > memberids(memberids_ptr);

        bool hasPublicInline = false;

        bool hasProtectedInline = false;

        for (unsigned int i = 0; i < memberids->size(); ++i)

        {

            const XMLCh * memberid = memberids->elementAt(i);

            HANodeIterator member(classNode);

            if ( member.FindNodeById(memberid) )

            {

                //Check every inline function but do not take artificial (compiler generated) functions into account

                if ( member.CheckForBooleanAttribute(KXMLInlineString) && !member.CheckForBooleanAttribute(KXMLArtificialString) )

                {

                    //Check if the constructor is protected or public

                    const XMLCh* attributeValue = member.GetAttribute(KXMLAccessString);

                    if ( Equals(attributeValue,KXMLProtectedString) )

                    {

                        //The class has protected inline function

                        hasProtectedInline = true;

                        classNode.SetAttribute(KXMLBBCProtectedInlineString,KXML1String);

                    }

                    if ( Equals(attributeValue,KXMLPublicString) )

                    {

                        //The class has public inline function

                        hasPublicInline = true;

                        classNode.SetAttribute(KXMLBBCPublicInlineString,KXML1String);

                    }

                    //It is enough if we have public inline, the class is fully exposed

                    if ( hasPublicInline )

                    {

                        return;

                    }

                }

            }

            else

            {

                //The tree is broken

                assert(false);

            }

        }

        //memberids->cleanup();

        //delete memberids;

    }

}

// ----------------------------------------------------------------------------

// BBCAnalyser::preAnalyseClass

// 

// ----------------------------------------------------------------------------

//

void BBCPreAnalysis::preAnalyseClass(HANodeIterator classNode)

{

    preAnalyseClassForVirtuality(classNode);

    preAnalyseClassForDerivability(classNode);

    preAnalyseClassForInlineFunctions(classNode);

}

// ----------------------------------------------------------------------------

// printNode

// DEBUG method

// 

// ----------------------------------------------------------------------------

//

void printNode(HANodeIterator node)

{

    DEBUG_STUFF(const XMLCh * name = node->getNodeName();)

    const XMLCh * value = node->getNodeValue();

    DEBUG_PRINT_XMLCh(name)

    if ( value )

    {

        DEBUG_PRINT(":")

        DEBUG_PRINT_XMLCh(value)

    }

    DOMNamedNodeMap * atts = node->getAttributes();

    if (atts)

    {

        DEBUG_PRINT(" attributes: ")

        XMLSize_t size = atts->getLength();

        for (unsigned int i = 0; i < size; ++i )

        {

            DOMNode * att = atts->item(i);

            HANodeIterator cit(node);

            cit.current = att;

            printNode(cit);

        }

    }

    DEBUG_PRINT("\n")

}

// ----------------------------------------------------------------------------

// BBCAnalyser::preAnalyseGenerateMaps

// 

// ----------------------------------------------------------------------------

//

void BBCPreAnalysis::preAnalyseGenerateMaps(HANodeIterator rootnode, bool baseline)

{

    //First generate the file maps	

    short nodetype = rootnode->getNodeType();

    assert(nodetype == DOMNode::ELEMENT_NODE);

#ifndef NO_DBG

    DEBUG_PRINT("****************preAnalyse: Generating index*********************\n")

    DEBUG_STUFF(time_t starttime = time(NULL);)

#endif

    DOMDocument * doc =  rootnode->getOwnerDocument();

    DOMNodeIterator * domit = doc->createNodeIterator (rootnode.current,DOMNodeFilter::SHOW_ELEMENT, NULL, true);

    DOMNode * it = NULL;

    while ( NULL != (it = domit->nextNode()) )

    {

        HANodeIterator childit(rootnode);

        childit.current = it;

#ifdef _DEBUG

        //printNode(childit);

        // Keep commented, too much stuff to print

#endif

        if (DOMNode::ELEMENT_NODE == childit->getNodeType())

        {

            childit.IndexNode();

        }

    }

#ifndef NO_DBG

    DEBUG_PRINT("****************preAnalyse: Generating index END*********************\n")

    DEBUG_STUFF(time_t endtime = time(NULL);)

    DEBUG_STUFF(time_t runningtime = endtime - starttime;)

    DEBUG_PRINT("ELAPSED TIME: ")

    DEBUG_PRINT((long)runningtime)

    DEBUG_PRINT("\n")

    DEBUG_PRINT("****************preAnalyse: Generating name map*********************\n")

    DEBUG_STUFF(time_t starttime2 = time(NULL);)

#endif

    doc =  rootnode->getOwnerDocument();

    domit = doc->createNodeIterator (rootnode.current,DOMNodeFilter::SHOW_ELEMENT, NULL, true);

    it = NULL;

    while ( NULL != (it = domit->nextNode()) )

    {

        HANodeIterator childit(rootnode);

        childit.current = it;		

        // Add node to name map if following conditions are true:

        // 1. Node is proper i.e. it is in proper context and it is not artificial (compiler generated).

        // 2. Node is named (class, enum, function.. etc.)

        // 3. It is declared in the analysed header OR it is not a baseline node. 

        //    Without this rule, classes that are moved to another, not to be analysed header,

        //    would not be properly analysed.

        if (IsProperNode(childit) && IsNamedNode(childit) && (childit.toBeAnalysed() || !baseline))

        {