diff -r 000000000000 -r 638b9c697799 apicompatanamdw/compatanalysercmd/headeranalyser/src/ClassNodeAnalysis.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/apicompatanamdw/compatanalysercmd/headeranalyser/src/ClassNodeAnalysis.h Tue Jan 12 14:52:39 2010 +0530 @@ -0,0 +1,325 @@ +/* +* 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: +* +*/ + + +#ifndef CLASSNODEANALYSIS_H_ +#define CLASSNODEANALYSIS_H_ + +#ifdef __WIN__ +#pragma warning(disable:4786) +#endif +#include +#include +#include +#include +#include "HANodeIterator.h" +#include "NodeAnalysis.h" +#include "NodeIndex.h" +#include "NodeTypeComparator.h" +using namespace std; + +XERCES_CPP_NAMESPACE_USE + + + +template +void AddIssueClass(const HANodeIterator* self,TIssueIdentity classType, const HANodeIterator& ignorenode, int lineNo, const XMLCh* fileid=NULL) +{ + switch (classType) + { + case EIssueIdentityClass: + AddIssue(self,ignorenode,lineNo,fileid); + break; + case EIssueIdentityStruct: + AddIssue(self,ignorenode,lineNo,fileid); + break; + case EIssueIdentityUnion: + AddIssue(self,ignorenode,lineNo,fileid); + break; + default: + assert(false); + break; + + }; +} + +template +void AddIssueField(const HANodeIterator* self,TIssueIdentity classType, const HANodeIterator& ignorenode, int lineNo, const XMLCh* fileid=NULL, const string name = "") +{ + switch (classType) + { + case EIssueIdentityField: + AddIssue(self,ignorenode,lineNo,fileid,name); + break; + case EIssueIdentityFieldInaccessible: + AddIssue(self,ignorenode,lineNo,fileid, name); + break; + default: + assert(false); + break; + + }; +} + +/** +* Add issue field +* @param self pointer to self +* @param classType type of issue +* @param ignorenode reference to node +* @param fileid pointer to fileid +* @param name reference to name +*/ +template +void AddIssueField(const HANodeIterator* self,TIssueIdentity classType, const HANodeIterator& ignorenode, int lineNo,const XMLCh* fileid, const DataMember & name) +{ + switch (classType) + { + case EIssueIdentityField: + AddIssue(self,ignorenode,lineNo,fileid,name); + break; + case EIssueIdentityFieldInaccessible: + AddIssue(self,ignorenode,lineNo,fileid, name); + break; + default: + assert(false); + break; + + }; +} + + +/** +* The member variables are analyzed for changes in order, type, removal, addition +* and visibility. Any change, including removal and addition, of the accessible +* data members of a class is reported. +*/ +class ClassNodeAnalysis: public NodeAnalysis +{ +public: + + static NodeAnalysis* Construct(); +public: + /** + * Constructor + */ + ClassNodeAnalysis(); + + /** + * Finds node to analyse it + * @param baseline baseline node + * @param current current node + * @return 0, if there was no issues + */ + int FindNodeAndAnalyse(HANodeIterator baseline,HANodeIterator current); + + /** + * Analyse + * @param baseline baseline node + * @param current current node + * @param report report or not (default= true) + * @return 0, if there was no issues + */ + int Analyse(HANodeIterator baseline,HANodeIterator current, bool report = true); + + /** + * Destructor + */ + ~ClassNodeAnalysis(){} + + +protected: + + /** + * Analyses fields + * @param baseline baseline version + * @param current current version + * @param bfields base fields vector + * @param cfields current fields vector + * @param report to report or not report issues + * @return 0 if compared fields are equal + */ + virtual int compareFields(HANodeIterator baseline,HANodeIterator current, + const vector& bfields, const vector& cfields, + bool report); + + /** + * Analyses non-virtual functions + * @param baseline baseline version + * @param current current version + * @param bexportedMethods base exported methods vector + * @param cexportedMethods current exported methods vector + * @param identity identity of the issue + * @param report to report or not report issues + * @return 0 if compared fields are equal + */ + virtual int compareNonvirtualFunctions( HANodeIterator baseline, + HANodeIterator current, + const vector& bexportedMethods, + const vector& cexportedMethods, + TIssueIdentity identity, + bool report); + + // First bool for signature + struct MethodMatchFlags + { + MethodMatchFlags(bool sM, bool rM) : signatureMatch(sM),returnValueMatch(rM){}; + bool signatureMatch; + bool returnValueMatch; + bool IsMatch() {return signatureMatch && returnValueMatch;}; + }; + + /** + * Analyses virtual functions + * @param baseline baseline version + * @param current current version + * @param bvirtualMethods base virtual methods vector + * @param cvirtualMethods current virtual methods vector + * @param report to report or not report issues + * @return 0 if compared fields are equal + */ + virtual int compareVirtualFunctions(HANodeIterator baseline,HANodeIterator current, + const vector& bvirtualMethods, + const vector& cvirtualMethods, + bool report); + /** + * Analyses other members + * @param baseline baseline version + * @param current current version + * @param bothers base other items vector + * @param cothers current other items vector + * @param report to report or not report issues + * @return 0 if compared fields are equal + */ + virtual int compareOthers(HANodeIterator baseline,HANodeIterator current, + const vector& bothers, const vector& cothers, + bool report); + + /** + * Compares the base sizes of the classes + * @param baseline to which to compare + * @param current what to compare + * @param bfields base data member table + * @param cfields current data member table + * @param report if true finding are reported + * @return 0 if compared fields are equal + */ + virtual int compareBaseSizes(HANodeIterator baseline, HANodeIterator current, const NodeIndex::dtable_t& bfields, const NodeIndex::dtable_t& cfields, bool report); + +protected: + + /** + * Compares changes in inheritance + * @param baseline to which to compare + * @param current what to compare + * @param report if true findings are reported + * @return 0 if compared fields are equal + */ + int compareBases(HANodeIterator baseline,HANodeIterator current, bool report); + + /** + * Compares methods by function signature (return value is not involved) + * @param basemethod basemethod to compare + * @param currentmethod current to compare + * @return true if signature isn't changed + */ + bool compareMethodsSignature(HANodeIterator basemethod,HANodeIterator currentmethod, const NodeTypeComparator& comparator); + + /** + * Compares all the members of the class + * @param baseline baseline version + * @param current current version + * @param report if true findings are reported + * @return 0 if there was no issues + */ + int compareClassMembers(HANodeIterator baseline,HANodeIterator current, bool report); + + /** + * Analyses and reports the differences between two fields + * @param basefield baseline field + * @param currentfield current field + * @param report if true findings are reported + * @return 0 if compared fields are equal + */ + //int compareField(HANodeIterator basefield,HANodeIterator currentfield, bool report); + + /** + * Analyses and reports the differences between two fields + * @param baseline baseline version + * @param current current version + * @param basemember base member to compare + * @param currentmember current member to compare + * @param report if true findings are reported + * @return 0 if compared fields are equal + */ + int compareField(HANodeIterator baseline, HANodeIterator current, const DataMember& basemember,const DataMember& currentmember, bool report); + + /** + * Analyses the methods return value + * @param basemethod baseline method + * @param currentmethod current method + * @return true if method returns are equal + */ + bool compareMethodsReturn(HANodeIterator basemethod,HANodeIterator currentmethod,NodeTypeComparator& cmp); + + /** + * Index virtual methods + * @param node node to index + * @param virtualMethods virtual methods in node + * @param vtable virtual method table + * @param virtualMethodsWithIndex methods indexed + */ + void indexVirtualMethods(HANodeIterator node, + const vector& virtualMethods, + const NodeIndex::vtable_t& vtable, + vector >& virtualMethodsWithIndex); + + /** + * Compare virtual methods + * @param baseline baseline version + * @param current current version + * @param basevtable base virtual method table + * @param currentvtable current virtual method table + * @param report if true findings are reported + */ + int compareVirtualTables(HANodeIterator baseline,HANodeIterator current, + const NodeIndex::vtable_t& basevtable, + const NodeIndex::vtable_t& currentvtable, + bool report); + + // Contains basemethod pointer and a boolean flag telling whether + // the method was found in current methods or not. + typedef map MethodMatchMap; + virtual int compareNonvirtualFunctions( HANodeIterator baseline, + HANodeIterator current, + const vector& bexportedMethods, + const vector& cexportedMethods, + TIssueIdentity identity, + bool report, + ComparatorVector::const_iterator comparator, + MethodMatchMap& baseMap, + MethodMatchMap& currMap, + int comparatorRound); + +protected: + + //! To report added members + bool iReportAddedMembers; + //! Identity of the issue found + TIssueIdentity iIdentity; +}; + +#endif