/*

* Copyright (c) 2007-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:  Functionality of function analysis 

*

*/

#include "la.hpp"

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

/**

 * This flags affects to the function comparison policy.

 */

// Default policy (=exact match):

#define COMPARE_FLAG_NONE                       0x00000000

// This flag means that adding a 'const' qualifier to a function

// parameter does not generate BBC break issue:

#define COMPARE_FLAG_ALLOW_CONST_ADDITION       0x00000001

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

// Forward declaration

class ParameterList;

// ParameterElement class represents a parameter element, which has an actual

// value and optional sub-parameters.

class ParameterElement

{

public:

    // Default constructor and destructor

    ParameterElement();

    virtual ~ParameterElement();

    // Copy constructor

    ParameterElement(const ParameterElement& rhs);

    // Assignment operator

    const ParameterElement& operator= (const ParameterElement& rhs);

    // Methods for getting the element value.

    string& Value() { return val; };

    const string& Value() const { return val; };

    // Methods for getting the sub-parameters.

    ParameterList* SubParameters() { return subPars; };

    const ParameterList* SubParameters() const { return subPars; };

    // Sets the sub-parameters. Takes the ownership to the given 

    // sub-parameter list pointer.

    void SetSubParameters( ParameterList* pPars );

    // Clears the value and sub-parameters.

    void Clear();

private:

    string val;

    ParameterList* subPars;

};

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

typedef vector<ParameterElement> FunctionParameter;

class ParameterList : public vector<FunctionParameter>

{};

ParameterElement::ParameterElement() 

{

    subPars = new ParameterList(); 

}

ParameterElement::~ParameterElement()

{

    delete subPars;

}

ParameterElement::ParameterElement(const ParameterElement& rhs)

{

    val = rhs.val;

    if( rhs.subPars )

        subPars = new ParameterList(*(rhs.subPars));

    else

        subPars = 0;

}

void ParameterElement::Clear() 

{

    val.clear();

    if( subPars )

        subPars->clear();

}

const ParameterElement& ParameterElement::operator= (const ParameterElement& rhs)

    {

        if( this != &rhs )

        {

            val = rhs.val;

            delete subPars;

            if( rhs.subPars )

                subPars = new ParameterList(*(rhs.subPars));

            else

                subPars = 0;

        }

        return *this;

    }

void ParameterElement::SetSubParameters( ParameterList* pPars )

{

    delete subPars;

    subPars = pPars;

}

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

/**

 * This structure represents the C++ cv-qualifier.

 */

struct CVQualifier

{

    static const string constQualifier;

    static const string volatileQualifier;

    static const string constVolatileQualifier;

    CVQualifier() { isConst = false; isVolatile = false; };

    /**

     * Set function gets <code>std::string</code> as an input and sets const 

     * and/or volatile flags according to the input.

     * @param cvStr String representing the const and / or volatile qualifier

     * i.e "const", "volatile" or "const volatile".

     */

    void Set(string const& cvStr)

    {

        if( cvStr == constQualifier )

        {

            isConst = true;         

            isVolatile = false;

        }

        else if( cvStr == volatileQualifier )

        {

            isConst = false;

            isVolatile = true;

        }

        else if( cvStr == constVolatileQualifier )

        {

            isConst = true;

            isVolatile = true;

        }        

        else

        {

            isConst = false;

            isVolatile = false;

        }

    };

    /**

     * Sets const and/or volatile flags

     * @param c 'const' qualifier. If TRUE, isConst flag is set to TRUE

     * @param v 'volatile' qualifier. If TRUE, isVolatile flag is set to TRUE

     */

    void Set( bool c, bool v )

    {

        isConst = c;

        isVolatile = v;

    };

    bool isConst;

    bool isVolatile;

};

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

const string CVQualifier::constQualifier = string("const");

const string CVQualifier::volatileQualifier = string("volatile");

const string CVQualifier::constVolatileQualifier = string("const volatile");

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

// This represents the function signature

struct FuncSignature

{    

    string nestedName; // name part

    ParameterList parameters; // parameters

    CVQualifier cvQualifier; // cv-qualifier of function

};

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

bool AreParametersCompatible(const FunctionParameter& basePar, const FunctionParameter& currPar, unsigned int CompareFlags = COMPARE_FLAG_NONE);

string::const_iterator RemoveSpaces(string::const_iterator start, string::const_iterator end, string::const_iterator& result);

string::size_type ReadCharsInTag(const string& sig, string& argElem, string::size_type startPos, pair<char, char> const& tag);

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

/**

 * Reads characters inside the given tag. Starts looking for the

 * starting tag at startPos. 

 * @param sig Reference to the string representing the function signature. 

 * @param argElem Reference to the string in which the parameter list is read.

 * @param startPos Tag starting point (e.g. '<' or '(') is startet to be searched

 *        after this location.

 * @param tag This object defines the starting and ending characters of the tag (e.g. '<' and '>').

 * @return Size of the string between the start and end characters of the tag.

 */

string::size_type ReadCharsInTag(const string& sig, string& argElem, string::size_type startPos, pair<char, char> const& tag)

{

    string::size_type sigLen = sig.size();

    if( sigLen == 0 )

    {

        return 0;

    }

    if( sig.at(startPos) != tag.first )

    {

        startPos = sig.find(tag.first, startPos);

    }

    string::size_type currPos = startPos;

    int tagCnt = 0; // This counter will be increased by 1 when tag starts and

                    // decreased by 1 when the tag ends. When it reaches zero,

                    // the tag has been completely read.

    do

    {            

        const char current = sig.at(currPos); // throws, if out of bounds

        if( current == tag.first )

            ++tagCnt; // tag starts

        else if( current == tag.second )

            --tagCnt; // tag ends

        ++currPos;

    }

    while( tagCnt > 0 );

    string::size_type len = currPos - startPos;

    if( len > 0 )

    {

        argElem.append(sig.begin() + startPos, sig.begin() + currPos);

    }

    return len;

}

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

/**

 * ParseParameterList. Recursively parses the given sub-string into

 * parameter list object.

 * @param funcSignature Reference to the string representing the function 

 *        signature.

 * @param parBegin Location where the parameter list starts.

 * @param parEnd Location where the parameter list ends.

 * @param parameters Parameter list of the function is returned here.

 */

void ParseParameterList(const string& funcSignature, 

                        string::size_type parBegin, 

                        string::size_type parEnd, 

                        ParameterList& parameters)

{    

    FunctionParameter par; // Object holding the current function parameter during parsing

    ParameterElement parElem; // Object holding the current parameter element during parsing

    while( parBegin <= parEnd )

    {

        char current = funcSignature.at(parBegin);

        switch( current )

        {

        case '(':

        case '<':

            {

                // Character '(' or '<' means that a new parameter list starts.

                // New parameter list is stored as a sub-parameter list of the current parameter.

                if( parElem.Value().size() > 0 )

                {

                    par.push_back(parElem); // Put the previous element in the list...

                    parElem.Clear(); // ...and clear the object for the next round.

                }

                string parListStr; // String representing the sub-parameterlist is stored here.

                int len = 0;

                char tagEndMark = current == '(' ? ')' : '>';

                // Put the value "<>" or "()"

                parElem.Value().push_back(current);

                parElem.Value().push_back(tagEndMark);

                // Read sub-parameters...

                len += ReadCharsInTag( funcSignature, parListStr, parBegin, make_pair(current, tagEndMark) );

                // ...and parse them

                if( parElem.SubParameters() == 0 )

                {

                    parElem.SetSubParameters(new ParameterList());

                }

                ParseParameterList(parListStr, 1, len-1, *(parElem.SubParameters()) );

                par.push_back(parElem); // Put the current element in the list...

                parElem.Clear(); // ...and clear the object for the next round.

                parBegin += len;

                break;

            }        

        case ' ':        

            {

                // space means that we have a new parameter element

                if( parElem.Value().size() > 0 )

                {

                    par.push_back(parElem); // Put the previous element in the list...

                    parElem.Clear(); // ...and clear the object for the next round.

                }

                ++parBegin;

                break;

            }

        case ',':

        case ')':

        case '>':

            {

                // Parameter completed

                if( parElem.Value().size() > 0 )

                {

                    par.push_back(parElem); // Put the previous element in the list...

                    parElem.Clear(); //...and clear the object for the next round.

                }

                if( par.size() > 0 )

                {

                    // Put the parameter in the parameter list...

                    parameters.push_back(par);

                    par.clear(); //...and clear the object for the next round.

                }

                ++parBegin;

                break;

            }

        case '*':

        case '&':

            {

                // We have a pointer or reference

                if( parElem.Value().size() > 0 )

                {

                    par.push_back(parElem); // Put the previous element in the list...

                    parElem.Clear(); //...and clear the object for the next round.

                }

                // Put also the current element in the list (i.e. '*' or '&')

                parElem.Value().push_back(current);

                par.push_back(parElem);

                parElem.Clear(); // ...and clear the object for the next round.

                ++parBegin;

                break;

            }

        default:

            {

                parElem.Value().push_back(funcSignature.at(parBegin));

                ++parBegin;

                break;

            }

        }        

    }

}

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

/**

 * ParseFunctionSignature

 * Parses function signature and returns following elements for the given 

 * function: 

 *  - name

 *  - parameters, which are splitted in elements and sub-parameters

 *  - cv-qualifier of the function

 *

 * Parameters are splitted in following elements: 

 *  - type (int, char, etc...)

 *  - cv-qualifier (const and/or volatile)

 *  - pointer symbol (*)

 *  - reference symbol (&)

 *  - parameter list "()" 

 *  - template parameter list "<>".

 *

 * Parameter lists are further splitted into sub-parameters, which also consists

 * of elements and sub-parameters.

 *

 * @param funcSignature Reference to the string representing the function signature

 * @param signature Parsed function signature is returned in this object.

 */

void ParseFunctionSignature( const string& funcSignature, FuncSignature& signature )

{    

    // Find the start and end positions of the "main" parameter list

    string::size_type openBracketIndex = funcSignature.find_first_of('(');

    string::size_type closeBracketIndex = funcSignature.find_last_of(')');

    if(openBracketIndex == string::npos || closeBracketIndex == string::npos )

    {     

        // No parameter list, so the given string may be for example 

        // "virtual table for MyClass"

        signature.nestedName = funcSignature;

        return;

    }

    // Remove preceding and trailing spaces from the function name part:

    string::const_iterator start;

    string::const_iterator end = RemoveSpaces(  

                                    funcSignature.begin(), 

                                    funcSignature.begin() + openBracketIndex,

                                    start);

    // Store the name part

    signature.nestedName.append(start, end); 

    // Parse function parameters

    ParseParameterList(funcSignature, openBracketIndex+1, closeBracketIndex, signature.parameters);

    // Parse the cv-qualifier of the function.

    end = RemoveSpaces(funcSignature.begin() + (closeBracketIndex+1), funcSignature.end(), start);

    signature.cvQualifier.Set(string(start,end));

}

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

/**

 * AreFunctionsCompatible

 * Compares two function signatures for backward binary compatibility. 

 * This function first parses the function signature into name, parameter list

 * and cv-qualifier parts. The name part is compared first and if names don't 

 * match, return false. Then parameter lists are given to 

 * <code>AreParametersCompatible</code> function for comparison. 

 * And finally cv-qualifiers of functions are compared. This comparison function

 * allows changing non-const function to const (i.e adding 'const'-qualifier for 

 * a function).

 * @param baselineFunc Reference to the string representing the baseline 

 *        platform's function signature

 * @param currentFunc Reference to the string representing the current

 *        platform's function signature

 * @return bool value indicating whether the two functions are backward binary

 *         compatible.

 */

TypeOfSeverity AreFunctionsCompatible(const string& baselineFunc, const string& currentFunc)

{ 

	TypeOfSeverity retSeverity = NO_BREAK;

    // First split functions into name part, parameter list and possible cv-qualifier:

    FuncSignature baseFunc;

    FuncSignature currFunc;

    ParseFunctionSignature(baselineFunc, baseFunc);

    ParseFunctionSignature(currentFunc, currFunc);

      // Check the const qualifier of the function:

    if( baseFunc.cvQualifier.isConst != currFunc.cvQualifier.isConst )

	  {        

		    // const qualifier of the function has been removed(either const to non-const or vise versa)

		    // Results in SC break    

		    retSeverity = CONFIRMED_SC_BREAK;

		goto EXIT_POINT;

	  }

	  // Check the number of parameters:

    if( baseFunc.parameters.size() != currFunc.parameters.size() )

    {

        retSeverity = POSSIBLE_BC_CONFIRMED_SC_BREAK; // Number of parameters does not match.

		goto EXIT_POINT;

    }

    // Then check name part:

    if( baseFunc.nestedName.compare(currFunc.nestedName) != 0 )

    {     

        retSeverity = POSSIBLE_BC_SC_BREAK; // Names do not match.

		goto EXIT_POINT;

    }

    // Check the parameters:       

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

    {

        if( AreParametersCompatible(baseFunc.parameters[i], currFunc.parameters[i], COMPARE_FLAG_ALLOW_CONST_ADDITION) == false )

        {            

            retSeverity = POSSIBLE_BC_SC_BREAK; // Parameters do not match

			goto EXIT_POINT;

        }

    }

    if( baseFunc.cvQualifier.isVolatile != currFunc.cvQualifier.isVolatile )

    {

        retSeverity = POSSIBLE_SC_BREAK; // volatile qualifier does not match

		goto EXIT_POINT;

    }

EXIT_POINT:

    return retSeverity;

}

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

/**

 * Removes preceding and trailing spaces from the given string

 * @return iterator to the end of the trimmed string.

 * @param start Iterator to the beginning of the string.

 * @param end Iterator to the end of the string.

 * @param result Iterator to the beginning of the trimmed string. 

 */

string::const_iterator RemoveSpaces(string::const_iterator start, 

                                    string::const_iterator end, 

                                    string::const_iterator& result)

{

    // Remove spaces from the beginning of the string:

    result = start;

    while( result != end && *result == ' ' )

    {

        ++result;

    }

    // Remove spaces from the end of the string:

    string::const_iterator resultEnd = end;

    while( resultEnd != result && *(resultEnd-1) == ' ' )

    {