/*

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

#include "Issues.h"

#include "XMLStringConst.h"

const char* KIgnoreInfoNone = "None";

// Textual descriptions for the severity levels

// Can be seen in the result xml

const char* KSeverityNULL = "None";

const char* KSeverityBBCBreak = "BBC Break";

const char* KSeverityPossibleBBCBreak = "Possible BBC Break";

const char* KSeverityFCBreak = "FC Break";

const char* KSeverityPossibleFCBreak = "Possible FC Break";

const char* KSeverityInformative = "Informative";

// Table of severity descriptions levels for binary compatibility

const char* KSeverityDesc[ESeverityCount] = 

{

    KSeverityNULL,

    KSeverityBBCBreak,

    KSeverityPossibleBBCBreak,

    KSeverityInformative,

	KSeverityFCBreak,

    KSeverityPossibleFCBreak

};

// Textual descriptions for the severity levels

// Can be seen in the result xml

const char* KSeveritySCNULL = "None";

const char* KSeveritySCBreak = "SC Break";

const char* KSeverityPossibleSCBreak = "Possible SC Break";

const char* KSeveritySCInformative = "Informative";

// Table of severity descriptions levels for source compatibility

const char* KSeveritySCDesc[ESeveritySCCount] = 

{

    KSeveritySCNULL,

    KSeveritySCBreak,

    KSeverityPossibleSCBreak,

    KSeveritySCInformative

};

// Textual descriptions for the identities

// Can be seen in the result xml

const char* KIdentityClass = "Class";

const char* KIdentityEnumeration = "Enumeration";

const char* KIdentityExportedFunction = "Exported function";

const char* KIdentityVirtualFunction = "Virtual function";

const char* KIdentityStruct = "Struct";

const char* KIdentityUnion = "Union";

const char* KIdentityEnumerationValue = "Enumeration value";

const char* KIdentityTypedef = "Typedef";

const char* KIdentityVariable = "Constant";

const char* KIdentityField = "Field";

const char* KIdentityFieldInaccessible = "Field";

const char* KIdentityFile = "File";

const char* KIdentityMacro = "Macro";

const char* KIdentityInlineFunction = "Inline function";

const char* KIdentityVirtualTable= "Virtual table";

const char*	KIdentitySubobject = "Subobject";

const char* KIdentityVirtualTablePointer = "Virtual table pointer";

const char* KIdentityExportedInlineFunction = "Exported inline function";

const char* KIdentityExportedVirtualFunction = "Exported virtual function";

const char* KIdentityVirtualInlineFunction = "Virtual inline function";

const char* KIdentityExportedVirtualInlineFunction = "Exported virtual inline function";

const char* KIdentityStructMember = "Strcut member";

// Table of the issue description

const char* KIssueIdentityDesc[EIssueIdentityCount] = 

{

    KIdentityClass,

    KIdentityExportedFunction,

    KIdentityInlineFunction,

    KIdentityVirtualFunction,

    KIdentityEnumeration,

    KIdentityStruct,

    KIdentityUnion,

    KIdentityEnumerationValue,

    KIdentityTypedef,

    KIdentityVariable,

    KIdentityField,

    KIdentityFieldInaccessible,

    KIdentityMacro,

    KIdentityFile,

    KIdentityVirtualTable,

    KIdentitySubobject,

    KIdentityVirtualTablePointer,

    KIdentityExportedInlineFunction,

    KIdentityExportedVirtualFunction,

    KIdentityVirtualInlineFunction,

    KIdentityExportedVirtualInlineFunction,

	KIdentityStructMember

};

// Textual descriptions for the issue types

// Can be seen in the result xml

const char* KIssueTypeRemoval = "has been removed";

const char* KIssueTypeAddition = "has been added";

const char* KIssueTypeChange = "has been changed";

const char* KIssueTypeSize = "has changed size";

const char* KIssueTypeBaseSize = "has changed base size";

const char* KIssueTypeAlign = "has changed alignment";

const char* KIssueTypeParam = "has changed one of its parameters";

const char* KIssueTypeParamConst = "has changed one of its parameters or funtion type";

const char* KIssueTypeParamConst2 = "has changed one of its parameters or funtion type";

const char* KIssueTypeReturn = "has changed its return value";

const char* KIssueTypeReturnConst = "has changed its return value";

const char* KIssueTypeReturnConst2 = "has changed its return value";

const char* KIssueTypeAccess = "has more restricted access level";

const char* KIssueTypeInheritance = "has changes in inheritance";

const char* KIssueTypeOffset = "has changed its offset";

const char* KIssueTypeOrderChange = "order has changed";

const char* KIssueTypeCompilationError = "has compilation errors";

const char* KIssueTypeNotAnalysed = "could not be analysed";

const char* KIssueTypeUnderConstruction = "analysis under construction";

const char* KIssueTypeVirtualBases = "has virtual bases";

const char* KIssueTypeChangeInType = "has changed its type";

const char* KIssueTypeChangeInInitialisation = "has changed its initialisation value";

const char* KIssueTypeNewOverride = "overridden in derivable class";

//const char* KIssueTypeRemovedOverride = "removed override in derivable class";

const char* KIssueTypeEmpty = "contains nothing to be analysed";

const char* KIssueTypeDefaultParam = "has changed one of its default parameters";

const char* KIssueTypeOverload = "has been overloaded";

// Table of the issue type descriptions

const char* KIssueTypeDesc[EIssueTypeCount] = 

{

    KIssueTypeRemoval,

    KIssueTypeAddition,

    KIssueTypeChange,

    KIssueTypeSize,

    KIssueTypeAlign,

    KIssueTypeParam,

	KIssueTypeReturn,

	KIssueTypeAccess,

    KIssueTypeInheritance,

    KIssueTypeOffset,

    KIssueTypeOrderChange,

    KIssueTypeChangeInType,

    KIssueTypeChangeInInitialisation,

    KIssueTypeCompilationError,

    KIssueTypeNotAnalysed,

    KIssueTypeVirtualBases,

    KIssueTypeNewOverride,

//	KIssueTypeRemovedOverride,

    KIssueTypeEmpty,

    KIssueTypeBaseSize,

    KIssueTypeUnderConstruction,

    KIssueTypeParamConst,

    KIssueTypeParamConst2,

	KIssueTypeReturnConst,

    KIssueTypeReturnConst2,

	KIssueTypeDefaultParam,

	KIssueTypeOverload

};

template <typename T>

string GetIgnoreInfoFromAttribute(const HANodeIterator& node, const T* attribute)

{

	string ignoreinfo="";

	const XMLCh* idx = node.GetAttribute(attribute);

	if (idx)

	{

		ignoreinfo = toString(idx);

	}

	return ignoreinfo;

}

/**

* In the following the severities and ignore information of issues are defined through template mechanism.

* This allows linking time checking that we have not forgot to define meaningful information for new issues.

* In order to modify severity information or ignore information first determine the TIssueIdentity and TIssueType

* of the issue and then find the correct function (BCseverityAccessible<TIssueIdentity,TIssueType>, 

* SCseverityAccessible<TIssueIdentity,TIssueType> and ignoreInfo<TIssueIdentity,TIssueType>) and modify the function

* definition to match with the severity and ignore information.

* The BCseverityAccessible function includes parameter [accessible] that defines if the element is directly accessible

* or only through some inline method.

*/

///////////////////////////////////////////////////////////////////////////////////////////////////////////

template <> TBCSeverity BCseverityAccessible<EIssueIdentityClass,EIssueTypeRemoval>(bool accessible)

{

	if ( !accessible )

	{

		return ESeverityPossibleBBCBreak;

	}

	return ESeverityBBCBreak;

}

template <> string ignoreInfo<EIssueIdentityClass,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)

{

	string ignoreinfo=KIgnoreInfoNone;

	return ignoreinfo;

}

//Size,                     

//ESeverityBBCBreak,        

template <> TBCSeverity BCseverityAccessible<EIssueIdentityClass,EIssueTypeSize>(bool accessible)

{

	if ( !accessible )

	{

		return ESeverityPossibleBBCBreak;

	}

	return ESeverityBBCBreak;

}

template <> string ignoreInfo<EIssueIdentityClass,EIssueTypeSize>(const HANodeIterator& baseline,const HANodeIterator& current)

{

	return  GetIgnoreInfoFromAttribute(current,KXMLSizeString);

}

//Align,                    

//ESeverityBBCBreak,        

template <> TBCSeverity BCseverityAccessible<EIssueIdentityClass,EIssueTypeAlign>(bool accessible)

{

	if ( !accessible )

	{

		return ESeverityPossibleBBCBreak;

	}

	return ESeverityBBCBreak;

}

template <> string ignoreInfo<EIssueIdentityClass,EIssueTypeAlign>(const HANodeIterator& baseline,const HANodeIterator& current)

{

	string ignoreinfo=KIgnoreInfoNone;

    const XMLCh* align = current.GetAttribute(KXMLAlignString);

	if (align)

	{

		ignoreinfo = toString(align);

	}

	return ignoreinfo;

}

//Access,                   

//ESeverityInformative,     

template <> TBCSeverity BCseverityAccessible<EIssueIdentityClass,EIssueTypeAccess>(bool accessible)

{

	if ( !accessible )

	{

		return ESeverityInformative;

	}

	return ESeverityInformative;

}

template <> string ignoreInfo<EIssueIdentityClass,EIssueTypeAccess>(const HANodeIterator& baseline,const HANodeIterator& current)

{

	string ignoreinfo=KIgnoreInfoNone;

	const XMLCh* access = current.GetAttribute(KXMLAccessString);

	if (access)

	{

		ignoreinfo = toString(access);

	}

	return ignoreinfo;

}

//Inheritance,              

//ESeverityPossibleBBCBreak,

template <> TBCSeverity BCseverityAccessible<EIssueIdentityClass,EIssueTypeInheritance>(bool accessible)

{

	if ( !accessible )

	{

		return ESeverityPossibleBBCBreak;

	}

	return ESeverityPossibleBBCBreak;

}

template <> string ignoreInfo<EIssueIdentityClass,EIssueTypeInheritance>(const HANodeIterator& baseline,const HANodeIterator& current)

{

	string ignoreinfo=KIgnoreInfoNone;

    DOMNodeList* childs = current.GetElementsByTagName(KXMLBaseString);

    XMLSize_t childcount = childs->getLength();

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

    {

        HANodeIterator baselineit(current);

        baselineit.current = childs->item(i);

        ignoreinfo += GetIgnoreInfoFromAttribute(baselineit,KXMLAccessString);

        ignoreinfo += " ";

        if (baselineit.CheckForBooleanAttribute(KXMLVirtualString) )

        {

            ignoreinfo += "virtual ";

        }							

        ignoreinfo += GetTypeName(baselineit);

        ignoreinfo += ";";

    }

	return ignoreinfo;

}

//KIssueNotAnalysed        

//ESeverityInformative,    	

template <> TBCSeverity BCseverityAccessible<EIssueIdentityClass,EIssueTypeNotAnalysed>(bool accessible)

{

	if ( !accessible )

	{

		return ESeverityInformative;

	}

	return ESeverityInformative;

}

template <> string ignoreInfo<EIssueIdentityClass,EIssueTypeNotAnalysed>(const HANodeIterator& baseline,const HANodeIterator& current)

{

	string ignoreinfo=KIgnoreInfoNone;

	return ignoreinfo;

}

//EIssueTypeVirtualBases

//Informative

template <> TBCSeverity BCseverityAccessible<EIssueIdentityClass,EIssueTypeVirtualBases>(bool accessible)

{

	if ( !accessible )

	{

		return ESeverityInformative;

	}

	return ESeverityInformative;

}

template <> string ignoreInfo<EIssueIdentityClass,EIssueTypeVirtualBases>(const HANodeIterator& baseline,const HANodeIterator& current)

{

	string ignoreinfo=KIgnoreInfoNone;

	return ignoreinfo;

}

//EIssueTypeBaseSize

//ESeverityBBCBreak

template <> TBCSeverity BCseverityAccessible<EIssueIdentityClass,EIssueTypeBaseSize>(bool accessible)

{

	if ( !accessible )

	{

		return ESeverityPossibleBBCBreak;

	}

	return ESeverityBBCBreak;

}

template <> string ignoreInfo<EIssueIdentityClass,EIssueTypeBaseSize>(const HANodeIterator& baseline,const HANodeIterator& current)

{

	string ignoreinfo=KIgnoreInfoNone;

	const NodeIndex::dtable_t& datafields = ClassGenerateDataMemberTable(current);

	int basesize = ClassBaseSize(current,datafields);

	ostringstream stream; 

	stream << basesize << flush;  

	ignoreinfo = stream.str();

	return ignoreinfo;

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////

//EIssueIdentityEnumeration,

//   Removal,                  

//    {ESeverityPossibleFCBreak,

template <> TBCSeverity BCseverityAccessible<EIssueIdentityEnumeration,EIssueTypeRemoval>(bool accessible)

{

	if ( !accessible )

	{

		return ESeverityPossibleFCBreak;

	}

	return ESeverityPossibleFCBreak;

}

template <> string ignoreInfo<EIssueIdentityEnumeration,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)

{

	string ignoreinfo=KIgnoreInfoNone;

	return ignoreinfo;

}

//Change,                   

//SeverityFCBreak, 

template <> TBCSeverity BCseverityAccessible<EIssueIdentityEnumeration,EIssueTypeChange>(bool accessible)

{

	if ( !accessible )

	{

		return ESeverityPossibleFCBreak;

	}

	return ESeverityPossibleFCBreak;

}

template <> string ignoreInfo<EIssueIdentityEnumeration,EIssueTypeChange>(const HANodeIterator& baseline,const HANodeIterator& current)

{

	string ignoreinfo=KIgnoreInfoNone;

    DOMNodeList* baselinechilds = current.GetElementsByTagName(KXMLEnumValueString);

    XMLSize_t baselinechildcount = baselinechilds->getLength();

    unsigned int i = 0;

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

    {

        HANodeIterator baselineit(current);

        baselineit.current = baselinechilds->item(i);

        ignoreinfo += GetIgnoreInfoFromAttribute(baselineit,KXMLNameString);

        ignoreinfo += "=";

        ignoreinfo += GetIgnoreInfoFromAttribute(baselineit,KXMLInitString);

        ignoreinfo += ";";

    }

	return ignoreinfo;

}

//Size,                     

//ESeverityFCBreak,      

template <> TBCSeverity BCseverityAccessible<EIssueIdentityEnumeration,EIssueTypeSize>(bool accessible)

{

	if ( !accessible )

	{

		return ESeverityPossibleFCBreak;

	}

	return ESeverityFCBreak;

}

template <> string ignoreInfo<EIssueIdentityEnumeration,EIssueTypeSize>(const HANodeIterator& baseline,const HANodeIterator& current)

{

	string ignoreinfo=KIgnoreInfoNone;

	const XMLCh* size = current.GetAttribute(KXMLSizeString);

	if (size)

	{

		ignoreinfo = toString(size);

	}

	return ignoreinfo;

}

//Align,                    

//ESeverityFCBreak,         

template <> TBCSeverity BCseverityAccessible<EIssueIdentityEnumeration,EIssueTypeAlign>(bool accessible)

{

	if ( !accessible )

	{

		return ESeverityPossibleFCBreak;

	}

	return ESeverityFCBreak;

}

template <> string ignoreInfo<EIssueIdentityEnumeration,EIssueTypeAlign>(const HANodeIterator& baseline,const HANodeIterator& current)

{

	string ignoreinfo=KIgnoreInfoNone;

	const XMLCh* align = current.GetAttribute(KXMLAlignString);

	if (align)

	{

		ignoreinfo = toString(align);

	}

	return ignoreinfo;

}

//Access,                   

//ESeverityInformative,   

template <> TBCSeverity BCseverityAccessible<EIssueIdentityEnumeration,EIssueTypeAccess>(bool accessible)

{

	if ( !accessible )

	{

		return ESeverityInformative;

	}

	return ESeverityInformative;

}

template <> string ignoreInfo<EIssueIdentityEnumeration,EIssueTypeAccess>(const HANodeIterator& baseline,const HANodeIterator& current)

{

	string ignoreinfo=KIgnoreInfoNone;

	const XMLCh* access = current.GetAttribute(KXMLAccessString);

	if (access)

	{

		ignoreinfo = toString(access);

	}

	return ignoreinfo;

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////

//EIssueIdentityExportedFunction,

//   Removal,                  

//   ESeverityBBCBreak,        

template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeRemoval>(bool accessible)

{

	if ( !accessible )

	{

		return ESeverityPossibleBBCBreak;

	}

	return ESeverityBBCBreak;

}

template <> string ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)

{

	string ignoreinfo=KIgnoreInfoNone;

	return ignoreinfo;

}

//	Param,                    

//	ESeverityBBCBreak,        

template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeParam>(bool accessible)

{

	if ( !accessible )

	{

		return ESeverityPossibleBBCBreak;

	}

	return ESeverityBBCBreak;