1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  

    15 *

    16 */

    17 

    18 #include <sstream>

    19 #include "Issues.h"

    20 #include "XMLStringConst.h"

    21 

    22 const char* KIgnoreInfoNone = "None";

    23 

    24 // Textual descriptions for the severity levels

    25 // Can be seen in the result xml

    26 const char* KSeverityNULL = "None";

    27 const char* KSeverityBBCBreak = "BBC Break";

    28 const char* KSeverityPossibleBBCBreak = "Possible BBC Break";

    29 const char* KSeverityFCBreak = "FC Break";

    30 const char* KSeverityPossibleFCBreak = "Possible FC Break";

    31 const char* KSeverityInformative = "Informative";

    32 

    33 // Table of severity descriptions levels for binary compatibility

    34 const char* KSeverityDesc[ESeverityCount] = 

    35 {

    36     KSeverityNULL,

    37     KSeverityBBCBreak,

    38     KSeverityPossibleBBCBreak,

    39     KSeverityInformative,

    40 	KSeverityFCBreak,

    41     KSeverityPossibleFCBreak

    42 };

    43 

    44 // Textual descriptions for the severity levels

    45 // Can be seen in the result xml

    46 const char* KSeveritySCNULL = "None";

    47 const char* KSeveritySCBreak = "SC Break";

    48 const char* KSeverityPossibleSCBreak = "Possible SC Break";

    49 const char* KSeveritySCInformative = "Informative";

    50 

    51 // Table of severity descriptions levels for source compatibility

    52 const char* KSeveritySCDesc[ESeveritySCCount] = 

    53 {

    54     KSeveritySCNULL,

    55     KSeveritySCBreak,

    56     KSeverityPossibleSCBreak,

    57     KSeveritySCInformative

    58 };

    59 

    60 

    61 // Textual descriptions for the identities

    62 // Can be seen in the result xml

    63 const char* KIdentityClass = "Class";

    64 const char* KIdentityEnumeration = "Enumeration";

    65 const char* KIdentityExportedFunction = "Exported function";

    66 const char* KIdentityVirtualFunction = "Virtual function";

    67 const char* KIdentityStruct = "Struct";

    68 const char* KIdentityUnion = "Union";

    69 const char* KIdentityEnumerationValue = "Enumeration value";

    70 const char* KIdentityTypedef = "Typedef";

    71 const char* KIdentityVariable = "Constant";

    72 const char* KIdentityField = "Field";

    73 const char* KIdentityFieldInaccessible = "Field";

    74 const char* KIdentityFile = "File";

    75 const char* KIdentityMacro = "Macro";

    76 const char* KIdentityInlineFunction = "Inline function";

    77 const char* KIdentityVirtualTable= "Virtual table";

    78 const char*	KIdentitySubobject = "Subobject";

    79 const char* KIdentityVirtualTablePointer = "Virtual table pointer";

    80 const char* KIdentityExportedInlineFunction = "Exported inline function";

    81 const char* KIdentityExportedVirtualFunction = "Exported virtual function";

    82 const char* KIdentityVirtualInlineFunction = "Virtual inline function";

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

    84 const char* KIdentityStructMember = "Strcut member";

    85 

    86 

    87 // Table of the issue description

    88 const char* KIssueIdentityDesc[EIssueIdentityCount] = 

    89 {

    90     KIdentityClass,

    91     KIdentityExportedFunction,

    92     KIdentityInlineFunction,

    93     KIdentityVirtualFunction,

    94     KIdentityEnumeration,

    95     KIdentityStruct,

    96     KIdentityUnion,

    97     KIdentityEnumerationValue,

    98     KIdentityTypedef,

    99     KIdentityVariable,

   100     KIdentityField,

   101     KIdentityFieldInaccessible,

   102     KIdentityMacro,

   103     KIdentityFile,

   104     KIdentityVirtualTable,

   105     KIdentitySubobject,

   106     KIdentityVirtualTablePointer,

   107     KIdentityExportedInlineFunction,

   108     KIdentityExportedVirtualFunction,

   109     KIdentityVirtualInlineFunction,

   110     KIdentityExportedVirtualInlineFunction,

   111 	KIdentityStructMember

   112 };

   113 

   114 // Textual descriptions for the issue types

   115 // Can be seen in the result xml

   116 const char* KIssueTypeRemoval = "has been removed";

   117 const char* KIssueTypeAddition = "has been added";

   118 const char* KIssueTypeChange = "has been changed";

   119 const char* KIssueTypeSize = "has changed size";

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

   121 const char* KIssueTypeAlign = "has changed alignment";

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

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

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

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

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

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

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

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

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

   131 const char* KIssueTypeOrderChange = "order has changed";

   132 const char* KIssueTypeCompilationError = "has compilation errors";

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

   134 const char* KIssueTypeUnderConstruction = "analysis under construction";

   135 const char* KIssueTypeVirtualBases = "has virtual bases";

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

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

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

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

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

   141 

   142 // Table of the issue type descriptions

   143 const char* KIssueTypeDesc[EIssueTypeCount] = 

   144 {

   145     KIssueTypeRemoval,

   146     KIssueTypeAddition,

   147     KIssueTypeChange,

   148     KIssueTypeSize,

   149     KIssueTypeAlign,

   150     KIssueTypeParam,

   151 	KIssueTypeReturn,

   152 	KIssueTypeAccess,

   153     KIssueTypeInheritance,

   154     KIssueTypeOffset,

   155     KIssueTypeOrderChange,

   156     KIssueTypeChangeInType,

   157     KIssueTypeChangeInInitialisation,

   158     KIssueTypeCompilationError,

   159     KIssueTypeNotAnalysed,

   160     KIssueTypeVirtualBases,

   161     KIssueTypeNewOverride,

   162 //	KIssueTypeRemovedOverride,

   163     KIssueTypeEmpty,

   164     KIssueTypeBaseSize,

   165     KIssueTypeUnderConstruction,

   166     KIssueTypeParamConst,

   167     KIssueTypeParamConst2,

   168 	KIssueTypeReturnConst,

   169     KIssueTypeReturnConst2    

   170 };

   171 

   172 template <typename T>

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

   174 {

   175 	string ignoreinfo="";

   176 	

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

   178 	if (idx)

   179 	{

   180 		ignoreinfo = toString(idx);

   181 	}

   182 	return ignoreinfo;

   183 }

   184 

   185 /**

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

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

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

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

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

   191 * definition to match with the severity and ignore information.

   192 

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

   194 * or only through some inline method.

   195 */

   196 ///////////////////////////////////////////////////////////////////////////////////////////////////////////

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

   198 {

   199 	if ( !accessible )

   200 	{

   201 		return ESeverityPossibleBBCBreak;

   202 	}

   203 	return ESeverityBBCBreak;

   204 }

   205 

   206 

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

   208 {

   209 	string ignoreinfo=KIgnoreInfoNone;

   210 

   211 	return ignoreinfo;

   212 }

   213 

   214 

   215 //Size,                     

   216 //ESeverityBBCBreak,        

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

   218 {

   219 	if ( !accessible )

   220 	{

   221 		return ESeverityPossibleBBCBreak;

   222 	}

   223 	return ESeverityBBCBreak;

   224 }

   225 

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

   227 {

   228 	return  GetIgnoreInfoFromAttribute(current,KXMLSizeString);

   229 }

   230 

   231 //Align,                    

   232 //ESeverityBBCBreak,        

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

   234 {

   235 	if ( !accessible )

   236 	{

   237 		return ESeverityPossibleBBCBreak;

   238 	}

   239 	return ESeverityBBCBreak;

   240 }

   241 

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

   243 {

   244 	string ignoreinfo=KIgnoreInfoNone;

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

   246 	if (align)

   247 	{

   248 		ignoreinfo = toString(align);

   249 	}

   250 	return ignoreinfo;

   251 }

   252 

   253 //Access,                   

   254 //ESeverityInformative,     

   255 

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

   257 {

   258 	if ( !accessible )

   259 	{

   260 		return ESeverityInformative;

   261 	}

   262 	return ESeverityInformative;

   263 }

   264 

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

   266 {

   267 	string ignoreinfo=KIgnoreInfoNone;

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

   269 	if (access)

   270 	{

   271 		ignoreinfo = toString(access);

   272 	}

   273 	return ignoreinfo;

   274 }

   275 

   276 //Inheritance,              

   277 //ESeverityPossibleBBCBreak,

   278 

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

   280 {

   281 	if ( !accessible )

   282 	{

   283 		return ESeverityPossibleBBCBreak;

   284 	}

   285 	return ESeverityPossibleBBCBreak;

   286 }

   287 

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

   289 {

   290 	string ignoreinfo=KIgnoreInfoNone;

   291     DOMNodeList* childs = current.GetElementsByTagName(KXMLBaseString);

   292 

   293     XMLSize_t childcount = childs->getLength();

   294 

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

   296     {

   297         HANodeIterator baselineit(current);

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

   299         

   300         ignoreinfo += GetIgnoreInfoFromAttribute(baselineit,KXMLAccessString);

   301         ignoreinfo += " ";

   302 

   303         if (baselineit.CheckForBooleanAttribute(KXMLVirtualString) )

   304         {

   305             ignoreinfo += "virtual ";

   306         }							

   307 

   308         ignoreinfo += GetTypeName(baselineit);

   309         ignoreinfo += ";";

   310     }

   311 

   312 	return ignoreinfo;

   313 }

   314 

   315 //KIssueNotAnalysed        

   316 //ESeverityInformative,    	

   317 

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

   319 {

   320 	if ( !accessible )

   321 	{

   322 		return ESeverityInformative;

   323 	}

   324 	return ESeverityInformative;

   325 }

   326 

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

   328 {

   329 	string ignoreinfo=KIgnoreInfoNone;

   330 

   331 	return ignoreinfo;

   332 }

   333 

   334 

   335 //EIssueTypeVirtualBases

   336 //Informative

   337 

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

   339 {

   340 	if ( !accessible )

   341 	{

   342 		return ESeverityInformative;

   343 	}

   344 	return ESeverityInformative;

   345 }

   346 

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

   348 {

   349 	string ignoreinfo=KIgnoreInfoNone;

   350 

   351 	return ignoreinfo;

   352 }

   353 

   354 //EIssueTypeBaseSize

   355 //ESeverityBBCBreak

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

   357 {

   358 	if ( !accessible )

   359 	{

   360 		return ESeverityPossibleBBCBreak;

   361 	}

   362 	return ESeverityBBCBreak;

   363 }

   364 

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

   366 {

   367 	string ignoreinfo=KIgnoreInfoNone;

   368 

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

   370 	int basesize = ClassBaseSize(current,datafields);

   371 

   372 	ostringstream stream; 

   373 	stream << basesize << flush;  

   374 	ignoreinfo = stream.str();

   375 

   376 	return ignoreinfo;

   377 }

   378 

   379 ///////////////////////////////////////////////////////////////////////////////////////////////////////////

   380 //EIssueIdentityEnumeration,

   381 //   Removal,                  

   382 //    {ESeverityPossibleFCBreak,

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

   384 {

   385 	if ( !accessible )

   386 	{

   387 		return ESeverityPossibleFCBreak;

   388 	}

   389 	return ESeverityPossibleFCBreak;

   390 }

   391 

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

   393 {

   394 	string ignoreinfo=KIgnoreInfoNone;

   395 

   396 	return ignoreinfo;

   397 }

   398 

   399 

   400 //Change,                   

   401 //SeverityFCBreak, 

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

   403 {

   404 	if ( !accessible )

   405 	{

   406 		return ESeverityPossibleFCBreak;

   407 	}

   408 	return ESeverityPossibleFCBreak;

   409 }

   410 

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

   412 {

   413 	string ignoreinfo=KIgnoreInfoNone;

   414 

   415     DOMNodeList* baselinechilds = current.GetElementsByTagName(KXMLEnumValueString);

   416     XMLSize_t baselinechildcount = baselinechilds->getLength();

   417     unsigned int i = 0;

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

   419     {

   420         HANodeIterator baselineit(current);

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

   422         ignoreinfo += GetIgnoreInfoFromAttribute(baselineit,KXMLNameString);

   423         ignoreinfo += "=";

   424         ignoreinfo += GetIgnoreInfoFromAttribute(baselineit,KXMLInitString);

   425         ignoreinfo += ";";

   426     }

   427 

   428 	return ignoreinfo;

   429 }

   430 

   431 //Size,                     

   432 //ESeverityFCBreak,      

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

   434 {

   435 	if ( !accessible )

   436 	{

   437 		return ESeverityPossibleFCBreak;

   438 	}

   439 	return ESeverityFCBreak;

   440 }

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

   442 {

   443 	string ignoreinfo=KIgnoreInfoNone;

   444 	

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

   446 	if (size)

   447 	{

   448 		ignoreinfo = toString(size);

   449 	}

   450 	return ignoreinfo;

   451 }

   452 

   453 //Align,                    

   454 //ESeverityFCBreak,         

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

   456 {

   457 	if ( !accessible )

   458 	{

   459 		return ESeverityPossibleFCBreak;

   460 	}

   461 	return ESeverityFCBreak;

   462 }

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

   464 {

   465 	string ignoreinfo=KIgnoreInfoNone;

   466 	

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

   468 	if (align)

   469 	{

   470 		ignoreinfo = toString(align);

   471 	}

   472 	return ignoreinfo;

   473 }

   474 

   475 //Access,                   

   476 //ESeverityInformative,   

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

   478 {

   479 	if ( !accessible )

   480 	{

   481 		return ESeverityInformative;

   482 	}

   483 	return ESeverityInformative;

   484 }

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

   486 {

   487 	string ignoreinfo=KIgnoreInfoNone;

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

   489 	if (access)

   490 	{

   491 		ignoreinfo = toString(access);

   492 	}

   493 	return ignoreinfo;

   494 }

   495 

   496 ///////////////////////////////////////////////////////////////////////////////////////////////////////////

   497 //EIssueIdentityExportedFunction,

   498 //   Removal,                  

   499 //   ESeverityBBCBreak,        

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

   501 {

   502 	if ( !accessible )

   503 	{

   504 		return ESeverityPossibleBBCBreak;

   505 	}

   506 	return ESeverityBBCBreak;

   507 }

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

   509 {

   510 	string ignoreinfo=KIgnoreInfoNone;

   511 

   512 	return ignoreinfo;

   513 }

   514 	

   515 //	Param,                    

   516 //	ESeverityBBCBreak,        

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

   518 {

   519 	if ( !accessible )

   520 	{

   521 		return ESeverityPossibleBBCBreak;

   522 	}

   523 	return ESeverityBBCBreak;

   524 }

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

   526 {

   527     string ignoreinfo=KIgnoreInfoNone;

   528     DOMElement * element = static_cast<DOMElement*>(current.current);

   529     DOMNodeList* childs = element->getChildNodes();

   530     

   531     XMLSize_t childcount = childs->getLength();

   532 

   533     unsigned int i = 0;

   534     for (i = 0; i < childcount; ++i)

   535     {

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

   537         HANodeIterator childit(current);

   538         childit.current = child;

   539 

   540         short nodetype = childit->getNodeType();

   541         if (nodetype == DOMNode::ELEMENT_NODE)

   542         {

   543             const XMLCh * defaultval = childit.GetAttribute(KXMLDefaultString);

   544             if ( defaultval )

   545             {

   546                 ignoreinfo += toString(defaultval);

   547             }

   548             else

   549             {

   550             }

   551             ignoreinfo += ";";

   552         }

   553 

   554     }

   555 	return ignoreinfo;

   556 }

   557 

   558 //	Param non-const to const,                    

   559 //	ESeverityNULL,        

   560 template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeParamConst>(bool accessible)

   561 {

   562 	if ( !accessible )

   563 	{

   564 		return ESeverityNULL;

   565 	}

   566 	return ESeverityNULL;

   567 }

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

   569 {

   570 	string ignoreinfo=KIgnoreInfoNone;

   571     //ignoreinfo = GenerateFunctionSignature(*this);

   572     DOMElement * element = static_cast<DOMElement*>(current.current);

   573     DOMNodeList* childs = element->getChildNodes();

   574     

   575     XMLSize_t childcount = childs->getLength();

   576 

   577     unsigned int i = 0;

   578     for (i = 0; i < childcount; ++i)

   579     {

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

   581         HANodeIterator childit(current);

   582         childit.current = child;

   583 

   584         short nodetype = childit->getNodeType();

   585         if (nodetype == DOMNode::ELEMENT_NODE)

   586         {

   587             const XMLCh * defaultval = childit.GetAttribute(KXMLDefaultString);

   588             if ( defaultval )

   589             {

   590                 ignoreinfo += toString(defaultval);

   591             }

   592             else

   593             {

   594             }

   595             ignoreinfo += ";";

   596         }

   597 

   598     }

   599 	return ignoreinfo;

   600 }

   601 

   602 //	Param const to non-const,                    

   603 //	ESeverityFCBreak,        

   604 template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeParamConst2>(bool accessible)

   605 {

   606 	if ( !accessible )

   607 	{

   608 		return ESeverityPossibleFCBreak;

   609 	}

   610 	return ESeverityFCBreak;

   611 }

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

   613 {

   614 	string ignoreinfo=KIgnoreInfoNone;

   615     //ignoreinfo = GenerateFunctionSignature(*this);

   616     DOMElement * element = static_cast<DOMElement*>(current.current);

   617     DOMNodeList* childs = element->getChildNodes();

   618     

   619     XMLSize_t childcount = childs->getLength();

   620 

   621     unsigned int i = 0;

   622     for (i = 0; i < childcount; ++i)

   623     {

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

   625         HANodeIterator childit(current);

   626         childit.current = child;

   627 

   628         short nodetype = childit->getNodeType();

   629         if (nodetype == DOMNode::ELEMENT_NODE)

   630         {

   631             const XMLCh * defaultval = childit.GetAttribute(KXMLDefaultString);

   632             if ( defaultval )

   633             {

   634                 ignoreinfo += toString(defaultval);

   635             }

   636             else

   637             {

   638             }

   639             ignoreinfo += ";";

   640         }

   641 

   642     }

   643 	return ignoreinfo;

   644 }

   645 

   646 //	Return,                   

   647 //	ESeverityBBCBreak,        

   648 template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeReturn>(bool accessible)

   649 {

   650 	if ( !accessible )

   651 	{

   652 		return ESeverityPossibleBBCBreak;

   653 	}

   654 	return ESeverityBBCBreak;

   655 }

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

   657 {

   658 	string ignoreinfo=KIgnoreInfoNone;

   659 

   660 	const XMLCh * baselineid = current.GetAttribute(KXMLReturnsString);

   661 	if (baselineid)

   662 	{

   663 		HANodeIterator newbaseline(current);

   664 		bool ret1=newbaseline.FindNodeById(baselineid);

   665 		if (ret1)

   666 		{

   667 			ignoreinfo += GetTypeName(newbaseline);

   668 		}

   669 	}

   670 

   671 	return ignoreinfo;

   672 }

   673 

   674 //	Return const to non-const,                   

   675 //	ESeverityNULL,        

   676 template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeReturnConst>(bool accessible)

   677 {

   678 	if ( !accessible )

   679 	{

   680 		return ESeverityNULL;

   681 	}

   682 	return ESeverityNULL;

   683 }

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

   685 {

   686 	string ignoreinfo=KIgnoreInfoNone;

   687 

   688 	const XMLCh * baselineid = current.GetAttribute(KXMLReturnsString);

   689 	if (baselineid)

   690 	{

   691 		HANodeIterator newbaseline(current);

   692 		bool ret1=newbaseline.FindNodeById(baselineid);

   693 		if (ret1)

   694 		{

   695 			ignoreinfo += GetTypeName(newbaseline);

   696 		}

   697 	}

   698 

   699 	return ignoreinfo;

   700 }

   701 

   702 //	Return non-const to const,                   

   703 //	ESeverityFCBreak,        

   704 template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeReturnConst2>(bool accessible)

   705 {

   706 	if ( !accessible )

   707 	{

   708 		return ESeverityPossibleFCBreak;

   709 	}

   710 	return ESeverityFCBreak;

   711 }

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

   713 {

   714 	string ignoreinfo=KIgnoreInfoNone;

   715 

   716 	const XMLCh * baselineid = current.GetAttribute(KXMLReturnsString);

   717 	if (baselineid)

   718 	{

   719 		HANodeIterator newbaseline(current);

   720 		bool ret1=newbaseline.FindNodeById(baselineid);

   721 		if (ret1)

   722 		{

   723 			ignoreinfo += GetTypeName(newbaseline);

   724 		}

   725 	}

   726 

   727 	return ignoreinfo;

   728 }

   729 

   730 //	Access,                               	

   731 //	ESeverityInformative,                 

   732 template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeAccess>(bool accessible)

   733 {

   734 	if ( !accessible )

   735 	{

   736 		return ESeverityInformative;

   737 	}

   738 	return ESeverityInformative;

   739 }

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

   741 {

   742 	string ignoreinfo=KIgnoreInfoNone;

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

   744 	if (access)

   745 	{

   746 		ignoreinfo = toString(access);

   747 	}

   748 	return ignoreinfo;

   749 }

   750 

   751 ///////////////////////////////////////////////////////////////////////////////////////////////////////////

   752 //EIssueIdentityInlineFunction,

   753 //   Removal,                  

   754 //    {ESeverityInformative,   

   755 template <> TBCSeverity BCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeRemoval>(bool accessible)

   756 {

   757 	if ( !accessible )

   758 	{

   759 		return ESeverityInformative;

   760 	}

   761 	return ESeverityInformative;

   762 }

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

   764 {

   765 	return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeRemoval>(baseline,current);

   766 }

   767 

   768 //	Param,                    

   769 //	ESeverityInformative,     

   770 template <> TBCSeverity BCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeParam>(bool accessible)

   771 {

   772 	if ( !accessible )

   773 	{

   774 		return ESeverityInformative;

   775 	}

   776 	return ESeverityInformative;

   777 }

   778 template <> string ignoreInfo<EIssueIdentityInlineFunction,EIssueTypeParam>(const HANodeIterator& baseline,const HANodeIterator& current)

   779 {

   780 	return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeParam>(baseline,current);

   781 }

   782 

   783 //	Param non-const to const,                    

   784 //	ESeverityNULL,        

   785 template <> TBCSeverity BCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeParamConst>(bool accessible)

   786 {

   787 	if ( !accessible )

   788 	{

   789 		return ESeverityNULL;

   790 	}

   791 	return ESeverityNULL;

   792 }

   793 template <> string ignoreInfo<EIssueIdentityInlineFunction,EIssueTypeParamConst>(const HANodeIterator& baseline,const HANodeIterator& current)

   794 {

   795 	return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeParamConst>(baseline,current);

   796 }

   797 

   798 //	Param const to non-const,                    

   799 //	ESeverityFCBreak,        

   800 template <> TBCSeverity BCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeParamConst2>(bool accessible)

   801 {

   802 	if ( !accessible )

   803 	{

   804 		return ESeverityInformative;

   805 	}

   806 	return ESeverityInformative;

   807 }

   808 template <> string ignoreInfo<EIssueIdentityInlineFunction,EIssueTypeParamConst2>(const HANodeIterator& baseline,const HANodeIterator& current)

   809 {

   810 	return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeParamConst2>(baseline,current);

   811 }

   812 

   813 //	Return,                   

   814 //	ESeverityInformative,     

   815 template <> TBCSeverity BCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeReturn>(bool accessible)

   816 {

   817 	if ( !accessible )

   818 	{

   819 		return ESeverityInformative;

   820 	}

   821 	return ESeverityInformative;

   822 }

   823 template <> string ignoreInfo<EIssueIdentityInlineFunction,EIssueTypeReturn>(const HANodeIterator& baseline,const HANodeIterator& current)

   824 {

   825 	return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeReturn>(baseline,current);

   826 }

   827 

   828 //	Return const to non-const,                   

   829 //	ESeverityNULL,        

   830 template <> TBCSeverity BCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeReturnConst>(bool accessible)

   831 {

   832 	if ( !accessible )

   833 	{

   834 		return ESeverityNULL;

   835 	}

   836 	return ESeverityNULL;

   837 }

   838 template <> string ignoreInfo<EIssueIdentityInlineFunction,EIssueTypeReturnConst>(const HANodeIterator& baseline,const HANodeIterator& current)

   839 {

   840 	return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeReturnConst>(baseline,current);

   841 }

   842 

   843 //	Return non-const to const,                   

   844 //	ESeverityFCBreak,        

   845 template <> TBCSeverity BCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeReturnConst2>(bool accessible)

   846 {

   847 	if ( !accessible )

   848 	{

   849 		return ESeverityPossibleFCBreak;

   850 	}

   851 	return ESeverityFCBreak;

   852 }

   853 template <> string ignoreInfo<EIssueIdentityInlineFunction,EIssueTypeReturnConst2>(const HANodeIterator& baseline,const HANodeIterator& current)

   854 {

   855 	return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeReturnConst2>(baseline,current);

   856 }

   857 

   858 //	Access,                   

   859 //	ESeverityInformative,     

   860 template <> TBCSeverity BCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeAccess>(bool accessible)

   861 {

   862 	if ( !accessible )

   863 	{

   864 		return ESeverityInformative;

   865 	}

   866 	return ESeverityInformative;

   867 }

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

   869 {

   870 	return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeAccess>(baseline,current);

   871 }

   872 

   873 ///////////////////////////////////////////////////////////////////////////////////////////////////////////

   874 //EIssueIdentityExportedVirtualFunction,

   875 //   Removal,                  

   876 //    {ESeverityBBCBreak,        

   877 template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedVirtualFunction,EIssueTypeRemoval>(bool accessible)

   878 {

   879 	if ( !accessible )

   880 	{

   881 		return ESeverityBBCBreak;

   882 	}

   883 	return ESeverityBBCBreak;

   884 }

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

   886 {

   887 	string ignoreinfo=KIgnoreInfoNone;

   888 

   889 	return ignoreinfo;

   890 }

   891 

   892 ///////////////////////////////////////////////////////////////////////////////////////////////////////////

   893 //EIssueIdentityVirtualFunction,

   894 //   Removal,                  

   895 //    {ESeverityBBCBreak,        

   896 template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeRemoval>(bool accessible)

   897 {

   898 	if ( !accessible )

   899 	{

   900 		return ESeverityBBCBreak;

   901 	}

   902 	return ESeverityBBCBreak;

   903 }

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

   905 {

   906 	string ignoreinfo=KIgnoreInfoNone;

   907 

   908 	return ignoreinfo;

   909 }

   910 

   911 //	Addition,                 

   912 //	ESeverityBBCBreak,        

   913 template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeAddition>(bool accessible)

   914 {

   915 	if ( !accessible )

   916 	{

   917 		return ESeverityBBCBreak;

   918 	}

   919 	return ESeverityBBCBreak;

   920 }

   921 template <> string ignoreInfo<EIssueIdentityVirtualFunction,EIssueTypeAddition>(const HANodeIterator& baseline,const HANodeIterator& current)

   922 {

   923 	string ignoreinfo=KIgnoreInfoNone;

   924 

   925 	return ignoreinfo;

   926 }

   927 

   928 //	Param,                    

   929 //	ESeverityBBCBreak,  

   930 

   931 template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeParam>(bool accessible)

   932 {

   933 	if ( !accessible )

   934 	{

   935 		return ESeverityBBCBreak;

   936 	}

   937 	return ESeverityBBCBreak;

   938 }

   939 template <> string ignoreInfo<EIssueIdentityVirtualFunction,EIssueTypeParam>(const HANodeIterator& baseline,const HANodeIterator& current)

   940 {

   941 	return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeParam>(baseline,current);

   942 }

   943 

   944 //	Return,                   

   945 //	ESeverityBBCBreak,     

   946 template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeReturn>(bool accessible)

   947 {

   948 	if ( !accessible )

   949 	{

   950 		return ESeverityBBCBreak;

   951 	}

   952 	return ESeverityBBCBreak;

   953 }

   954 template <> string ignoreInfo<EIssueIdentityVirtualFunction,EIssueTypeReturn>(const HANodeIterator& baseline,const HANodeIterator& current)

   955 {

   956 	string ignoreinfo=KIgnoreInfoNone;

   957 	return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeReturn>(baseline,current);

   958 }

   959 

   960 //	Access,                   

   961 //	ESeverityInformative,     

   962 template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeAccess>(bool accessible)

   963 {

   964 	if ( !accessible )

   965 	{

   966 		return ESeverityInformative;

   967 	}

   968 	return ESeverityInformative;

   969 }

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

   971 {

   972 	string ignoreinfo=KIgnoreInfoNone;

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

   974 	if (access)

   975 	{

   976 		ignoreinfo = toString(access);

   977 	}

   978 	return ignoreinfo;}

   979 

   980 //	OrderChange,              	

   981 //	ESeverityBBCBreak,        

   982 template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeOrderChange>(bool accessible)

   983 {

   984 	if ( !accessible )

   985 	{

   986 		return ESeverityBBCBreak;

   987 	}

   988 	return ESeverityBBCBreak;

   989 }

   990 template <> string ignoreInfo<EIssueIdentityVirtualFunction,EIssueTypeOrderChange>(const HANodeIterator& baseline,const HANodeIterator& current)

   991 {

   992 	string ignoreinfo=KIgnoreInfoNone;

   993 	

   994 	const XMLCh* idx = current.GetAttribute(KXMLBBCVirtualFunctionIndex);

   995 	if (idx)

   996 	{

   997 		ignoreinfo = toString(idx);

   998 	}

   999 	return ignoreinfo;

  1000 }

  1001 

  1002 

  1003 //	KIssueTypeNewOverride,

  1004 //	ESeverityBBCBreak,        

  1005 template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeNewOverride>(bool accessible)

  1006 {

  1007 	if ( !accessible )

  1008 	{

  1009 		return ESeverityBBCBreak;

  1010 	}

  1011 	return ESeverityBBCBreak;

  1012 }

  1013 template <> string ignoreInfo<EIssueIdentityVirtualFunction,EIssueTypeNewOverride>(const HANodeIterator& baseline,const HANodeIterator& current)

  1014 {

  1015 	string ignoreinfo=KIgnoreInfoNone;

  1016 	return ignoreinfo;

  1017 }

  1018 

  1019 

  1020 ///////////////////////////////////////////////////////////////////////////////////////////////////////////

  1021 //EIssueIdentityStruct,

  1022 //   Removal,                  

  1023 //    {ESeverityBBCBreak,	       

  1024 template <> TBCSeverity BCseverityAccessible<EIssueIdentityStruct,EIssueTypeRemoval>(bool accessible)

  1025 {

  1026 	if ( !accessible )

  1027 	{

  1028 		return ESeverityPossibleBBCBreak;

  1029 	}

  1030 	return ESeverityBBCBreak;

  1031 }

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

  1033 {

  1034 	return ignoreInfo<EIssueIdentityClass,EIssueTypeRemoval>(baseline,current);

  1035 }

  1036 

  1037 //	BaseSize,                     

  1038 //	ESeverityBBCBreak,        

  1039 template <> TBCSeverity BCseverityAccessible<EIssueIdentityStruct,EIssueTypeBaseSize>(bool accessible)

  1040 {

  1041 	return BCseverityAccessible<EIssueIdentityClass,EIssueTypeBaseSize>(accessible);

  1042 }

  1043 

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

  1045 {

  1046 	return ignoreInfo<EIssueIdentityClass,EIssueTypeBaseSize>(baseline,current);

  1047 }

  1048 

  1049 // EIssueTypeNotAnalysed

  1050 // ESeverityInformative

  1051 template <> TBCSeverity BCseverityAccessible<EIssueIdentityStruct,EIssueTypeNotAnalysed>(bool accessible)

  1052 {

  1053 	if ( !accessible )

  1054 	{

  1055 		return ESeverityInformative;

  1056 	}

  1057 	return ESeverityInformative;

  1058 }

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

  1060 {

  1061 	return ignoreInfo<EIssueIdentityClass,EIssueTypeNotAnalysed>(baseline,current);

  1062 }

  1063 

  1064 

  1065 //	Size,                     

  1066 //	ESeverityBBCBreak,        

  1067 template <> TBCSeverity BCseverityAccessible<EIssueIdentityStruct,EIssueTypeSize>(bool accessible)

  1068 {

  1069 	if ( !accessible )

  1070 	{

  1071 		return ESeverityPossibleBBCBreak;

  1072 	}

  1073 	return ESeverityBBCBreak;

  1074 }

  1075 

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

  1077 {

  1078 	return ignoreInfo<EIssueIdentityClass,EIssueTypeSize>(baseline,current);

  1079 }

  1080 //	Align,                    

  1081 //	ESeverityBBCBreak,        

  1082 template <> TBCSeverity BCseverityAccessible<EIssueIdentityStruct,EIssueTypeAlign>(bool accessible)

  1083 {

  1084 	if ( !accessible )

  1085 	{

  1086 		return ESeverityPossibleBBCBreak;

  1087 	}

  1088 	return ESeverityBBCBreak;

  1089 }

  1090 

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

  1092 {

  1093 	return ignoreInfo<EIssueIdentityClass,EIssueTypeAlign>(baseline,current);

  1094 }

  1095 //	Access,                   

  1096 //	ESeverityInformative,     

  1097 template <> TBCSeverity BCseverityAccessible<EIssueIdentityStruct,EIssueTypeAccess>(bool accessible)

  1098 {

  1099 	if ( !accessible )

  1100 	{

  1101 		return ESeverityInformative;

  1102 	}

  1103 	return ESeverityInformative;

  1104 }

  1105 

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

  1107 {

  1108 	return ignoreInfo<EIssueIdentityClass,EIssueTypeAccess>(baseline,current);

  1109 }

  1110 //	Inheritance,              

  1111 //	ESeverityPossibleBBCBreak,

  1112 template <> TBCSeverity BCseverityAccessible<EIssueIdentityStruct,EIssueTypeInheritance>(bool accessible)

  1113 {

  1114 	if ( !accessible )

  1115 	{

  1116 		return ESeverityPossibleBBCBreak;

  1117 	}

  1118 	return ESeverityPossibleBBCBreak;

  1119 }

  1120 

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

  1122 {

  1123 	return ignoreInfo<EIssueIdentityClass,EIssueTypeInheritance>(baseline,current);

  1124 }

  1125 

  1126 //EIssueTypeVirtualBases

  1127 //Informative

  1128 

  1129 template <> TBCSeverity BCseverityAccessible<EIssueIdentityStruct,EIssueTypeVirtualBases>(bool accessible)

  1130 {

  1131 	if ( !accessible )

  1132 	{

  1133 		return ESeverityInformative;

  1134 	}