1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Limitations:

    15 // Leavescan will attempt to avoid comments, strings and char literals which it

    16 // finds within the code. It is also capable of recognising escaped quotes,

    17 // but complex combinations of escaping e.g. "\\\"\"\'" may fool the parser and

    18 // result in false positives, or cause parsing to terminate prematurely (resulting

    19 // in possible unreported problems.

    20 // Leavescan can only parse what it sees, and is therefore oblivious to any 

    21 // non-trivial attempt to call a leaving function (i.e. by function pointer)

    22 // Macros can also fool the parser (as is), but leavscan will now indicate

    23 // whether the leaving invocation may, in fact, be a macro.

    24 // Multiple files are now supported on the command-line, along with some basic

    25 // options such as '-v' which will dump the version. Invoking with no 

    26 // parameters will dump the version & help, so that automated build systems can

    27 // check the version and cater for enhanced behaviour.

    28 // Local Version:

    29 // $Id: leavescan2.cpp,v 1.6 2003/02/19 12:59:00 AndrewHa Exp $

    30 // 

    31 //

    32 

    33 

    34 #include <fstream>

    35 #include <iostream>

    36 #include <sstream>   

    37 #include <string>

    38 #include <assert.h>

    39 #include <list>

    40 

    41 #define FOREVER for(;;)

    42 

    43 //static const char Kversion[] = "0.06"; // Version updated 07 March 08

    44 static const char Kversion[] = "0.07";  // suprrot L class, fix some defects.Version updated 07/2008

    45 // Shorthand

    46 typedef unsigned int uint;

    47 

    48 // Set of match types. E_Last must be at the end of the list.

    49 enum TMatchTypes { 

    50   E_LCleanedUp=0,

    51   E_LString,

    52   E_LManaged,

    53   E_LData,

    54   E_Ell , 

    55   E_Trap, 

    56   E_BlockComment, 

    57   E_LineComment, 

    58   E_Eleave, 

    59   E_UserEleave, 

    60   E_String,

    61   E_Quote,

    62   E_OpenBrace,

    63   E_CloseBrace,

    64   E_OrLeave,

    65   E_Last };

    66 

    67 // Set of return values of GetFunc().

    68 enum TReturnTypes {

    69   E_False = 0,

    70   E_True,

    71   E_Continue };

    72   

    73 enum TPPState { 

    74    PPSTATE_NORMAL=0,

    75    PPSTATE_ESCAPED_LINE ,

    76    PPSTATE_SINGLE_COMMENT,

    77    PPSTATE_MUL_COMMENT,

    78    PPSTATE_STRING_LITERAL,

    79    PPSTATE_SHARP_COMMENT

    80   };

    81 

    82 enum TClassMemberTypes { 

    83     E_NA= 0, 

    84     E_MemberData, 

    85     E_MemberFunctionDecl, 

    86     E_MemberFunctionDef, 

    87     E_Enum

    88     };

    89 

    90 using namespace std;

    91 struct ClassMeta {

    92 	 string className ;

    93 	 int startPos;

    94 	 int endPos;

    95 };

    96 

    97 class TLeaveScanModel

    98 {

    99 public:

   100   bool  Scan(ifstream& aStream);

   101   void  SetFileName(char* aName);

   102   char* FileName();

   103   int   Verbose;

   104   bool OnlyPrePrecess;

   105 

   106 private:	

   107   void  FileToText(ifstream& aStream, string& aText);

   108   enum  TReturnTypes  GetFunc(const string& aFile, string &name, uint &start, uint &end);

   109   bool  CheckFunc(const string& aFile, string& aName, uint start, uint end, bool& aIsLeaver);

   110   bool  MoveToEndOfTrapHarness(const string& aStr, uint& aIndex, uint aLen);

   111   void  MoveToEndOfComment(const string& aStr, uint& aIndex, uint aLen);

   112   void  MoveToEndOfLine(const string& aStr, uint& aIndex, uint aLen);

   113   void  MoveToEndOfString(const string& aStr, uint& aIndex, uint aLen, char aQuote);

   114   uint  GetRealStartPosition(const string& aFile, uint aStart, uint aIsvalidDoublecolon);

   115   void  Peek(const string aStr, uint aPos);

   116   uint  SmartFind(const string& aStr, const string& aTarget, uint aStart);

   117   uint  SmartFindEndOfString(const string& aStr, uint aPos, char aQuote);

   118   bool  IsInCommentScopeOrKeyword(const string& aFile, string &aName, uint aStartposition, uint aStartbraceposn);

   119   bool  IsFunctionNameStringNotAMacro(const string& aFile, uint aStartbraceposn, uint aTempParenPos, uint aNstart);

   120   bool  IsSemiColonAndAssignmentOccurs(const string& aFile, uint aStartbraceposn, uint aTempParenPos);

   121   bool  CheckValidFuncName(const string& aFile, uint aStart);

   122   bool  CheckForTemplateFunc(const string& aFile, uint nstart, uint nend);

   123   uint  FindFirstMatchType(uint aMatchSet[]);

   124   string PreProcess(const string& aFile);

   125   string CombineLine(const string& aFile);

   126   list<ClassMeta> GetClass(const string& aFile);

   127   int GetLeftParenthesis(const string& aText, uint pos);

   128   int GetRightParenthesis(const string& aText, uint pos);

   129   int GetLeftTmpltParentBack(const string& aText,uint pos);

   130   int GetRightTmpltParent(const string& aText,uint pos);

   131   bool IsClassKeyword(const string& aText, uint aBegin, uint aEnd);

   132   int GetLeftBracket(const string& aText,uint pos);

   133   int GetRightBracket(const string& aText,uint pos);

   134   void CheckClass(const string& aText , const string& aClassName, uint start,uint end);

   135   void CheckInClassFunc(const string& aText , const string& aClassName, const string& aFuncName, uint start,uint end);

   136   bool IsLClassCtor(const string& aName);

   137   bool IsInClassScope(uint pos);

   138   string GetFunctNameFromFuncHead(const string& aFuncHead);

   139   string GetFunctionParam(const string& aText, uint aStart);

   140   string GetFunctionHead(const string& aText, uint aStart);

   141   string GetErrorLineHead(const string& aText,uint aStart);

   142   string GetClassName(uint aStart);

   143   void  ReportErrorLineAndString(uint aStart);

   144   bool  AppendCommentToErrorString(uint aEnd);

   145   bool  IdentifyMacro(const string& str, const uint aPos);

   146   void  Test1();

   147   void  Test2L();

   148   void  Test3();

   149   void  Test4();

   150   

   151   inline bool IsNewLine(const char& aCurChar) {return ((aCurChar)=='\n'||(aCurChar)=='\r')?true:false;}

   152   inline bool IsLastChar(uint aCurPos, uint aStringLength) { return ((aCurPos+1)==aStringLength)?true:false;}

   153   inline bool HasEnoughChar(uint aCurPos,uint aStringLength,uint aWanted) {return (aStringLength-aCurPos-1>=aWanted)?true:false;}

   154   inline string TrimString(const string& aStr)

   155   {

   156 	string result = aStr;

   157 	result.erase(result.find_last_not_of(" \t\n\r")+1);

   158 	result.erase(0,result.find_first_not_of(" \t\n\r"));

   159 	return result;

   160   }

   161 private:

   162   string	iText;

   163   string	iBody;

   164   string	iErrorString;

   165   list<ClassMeta> iClassList;

   166   int	        iPositionOfError;

   167   char*         iFileName;

   168   

   169 };

   170 

   171 void pversion()

   172 {

   173   cout << "Leavescan version: " << Kversion <<"(build time:"<<__DATE__<<" "<<__TIME__<<")\n";

   174 }

   175 

   176 void pusage()

   177 {

   178   pversion();

   179   cout << "syntax: \n\tleavescan [-h|-n|-v|-N] <iFilename.cpp> [<iFilename.cpp> ...]\n\n";

   180   cout << "\t-h: This help.\n";

   181   cout << "\t-n: Noisy output - provides diagnostics (if available).\n";

   182   cout << "\t-N: Very noisy output - provides diagnostics (if available).\n";

   183   cout << "\t-v: Displays version (for build & automation systems).\n";

   184   cout << "\t-E: Only do pre-process\n\n";

   185 

   186 }

   187 

   188 int main(int argc, char** argv)

   189 {

   190   int noisy = 0;

   191   bool onlyPreProcess =false;

   192   if (argc < 2)

   193     {

   194       pusage();

   195       return 1;

   196     }

   197   

   198   for (int clparam = 1; clparam < argc; clparam++)

   199     {

   200       if (argv[clparam][0] == '-')

   201 	{

   202 	  switch(argv[clparam][1])

   203 	    {

   204 	    case 'n':

   205 	      noisy = 1;

   206 	      break;

   207 	    case 'N':

   208 	      noisy = 2;

   209 	      break;

   210 	    case 'h':

   211 	      pusage();

   212 	      break;

   213 	    case 'v':

   214 	      pversion();

   215 	      break;

   216 	    case 'E':

   217 	    	{

   218 	    		onlyPreProcess = true;

   219 	    	}

   220 	      break;

   221 	    default:

   222 	      pusage();

   223 	      break;

   224 	    }

   225 	} //if

   226       else

   227 	{

   228 	  // invoked once per file

   229 	  TLeaveScanModel model;

   230 	  model.SetFileName(argv[clparam]);

   231 	  model.Verbose = noisy;

   232 	  if(onlyPreProcess)

   233 	  {

   234 		  model.OnlyPrePrecess = true;

   235 	  }

   236 	  else

   237 	  {

   238 		  model.OnlyPrePrecess = false;

   239 	  }

   240 	  ifstream file(model.FileName());

   241 	  (void) model.Scan(file);

   242 	  file.close();

   243 	  //	  return 0;

   244 	}

   245     }

   246   return 0;

   247 }

   248   

   249 void TLeaveScanModel::SetFileName(char *aName)

   250 {

   251   iFileName = aName;

   252 }

   253 

   254 char* TLeaveScanModel::FileName()

   255 {

   256   return iFileName;

   257 }

   258 

   259 //

   260 // Main processing function which converts the file to a basic::string

   261 // and then searches through for methods, analysing them as they are

   262 // located.

   263 bool TLeaveScanModel::Scan(ifstream& aStream)

   264 {

   265   FileToText(aStream, iText);

   266   string oldText(iText);

   267   iText = PreProcess(iText);

   268   if(OnlyPrePrecess)

   269 	  {

   270 	  	cout<<iText;

   271 	  	return false;

   272 	  }

   273   if(!iText.length())

   274     {

   275       cout << "File not found or empty.\n";

   276       return false;

   277     }

   278   

   279   uint start  = 0;

   280   uint end    = 0;

   281   bool isLeaver;

   282   enum TReturnTypes getFuncReturnTypes;

   283   //init class list

   284   iClassList = GetClass(iText);

   285   //check function

   286   while (start < iText.length())

   287     {

   288       string name;

   289 	  getFuncReturnTypes = E_Continue;

   290 	  while(getFuncReturnTypes == E_Continue)

   291 	  {

   292 		  getFuncReturnTypes = GetFunc(iText, name, start, end);

   293 	  }

   294       if (!getFuncReturnTypes)

   295 		break;

   296       

   297       bool clean = CheckFunc(iText, name, start, end, isLeaver);

   298       bool isLCFunc =false;

   299       if(name[name.length()-1] == 'C' && name[name.length()-2] == 'L')

   300       {

   301     	  isLCFunc = true;

   302       }

   303       if (isLeaver) // was a leaving container(safe) and no leavers found

   304       {

   305     	  

   306     	  if (clean)

   307     	  {

   308     		  iPositionOfError=0;

   309     		  iErrorString = "Warning - " + name + " appears to contain no leavers.";

   310     		  if(!IsInClassScope(start))

   311 			  {

   312 				  ReportErrorLineAndString(start);	  

   313 			  }

   314     	  }

   315     	  else if(isLCFunc)

   316     	  {

   317     	      

   318 			  uint lcleanedupPos = iErrorString.find("LCleanedup");

   319 			  if(lcleanedupPos!=string::npos)

   320 				{

   321     	    	  uint callPos = iErrorString.find(" calls ");

   322 				  uint lcleanedupPosInFuncName = name.find("LCleanedup");

   323 				  if(callPos!=string::npos && lcleanedupPosInFuncName!=string::npos && lcleanedupPos<callPos)

   324 				  {;}

   325 				  else

   326 				  {

   327 					iErrorString = "LCleanedup class is used in a function suffixed LC";

   328     	    		if(!IsInClassScope(start))

   329 					{

   330 						ReportErrorLineAndString(start);	  

   331 					}

   332 				  }

   333 				}

   334     	  }

   335 

   336     	  // any leavers info can be supressed here since container was leaver

   337       }

   338       else // wasn't a leaving container 

   339       {

   340     	  if (!clean) // was dirty, so report

   341     		  if(!IsInClassScope(start))

   342 			  {

   343 				  ReportErrorLineAndString(start);	  

   344 			  }

   345       }

   346       start = end;

   347     }

   348   //check class 

   349   list<ClassMeta>::iterator iter; 

   350   for(iter=iClassList.begin();iter!=iClassList.end();iter++) 

   351   { 

   352 	  CheckClass(iText,iter->className,iter->startPos,iter->endPos);

   353   } 

   354   return true;

   355 }

   356 

   357 //

   358 // Spool a file into one large basic::string

   359 //

   360 void TLeaveScanModel::FileToText(ifstream& aStream, string& aText)

   361 {

   362   char data[1024];

   363   int len;

   364   do	

   365     {

   366       aStream.read(data,1024);

   367       len = aStream.gcount();

   368       aText.append(data, len);

   369     }

   370   while(len);

   371 }

   372 

   373 // To get the actual position of starting parenthesis for a function definition

   374 //

   375 uint TLeaveScanModel::GetRealStartPosition(const string& aFile,uint aStart, uint aIsvaliddoublecolon)

   376 {

   377 	uint realstartpos = 0;

   378 

   379 	// The opening parenthesis which comes fist after opening brace while moving

   380  	// in backward direction is a valid candidate for function name.

   381 		

   382 	uint firstcurlybrace = SmartFind(aFile, "{", aStart + 1 ); // advance start

   383 

   384 	if ((firstcurlybrace == string::npos) || (firstcurlybrace >= aFile.length())) 

   385 	{

   386 		return realstartpos;

   387 	}

   388 

   389 	// This variable will store the first paranthesis position

   390 	uint tempParenPos = aFile.find_last_of('(',firstcurlybrace);

   391 

   392 	if (tempParenPos == string::npos)

   393 	{

   394 		// No '(' found yet

   395 		return realstartpos;

   396 	}

   397 

   398 	if (aIsvaliddoublecolon == 1)

   399 	{ 

   400 		tempParenPos = aStart;	

   401 	}

   402 	

   403 	string whiteSpaceChars = " \t\n\r*&";

   404 	

   405 	// ignore all tab and spaces between function name and opening parenthesis

   406 	uint nend = aFile.find_last_not_of(whiteSpaceChars, --tempParenPos);

   407 	uint pos = aFile.find_last_of(whiteSpaceChars, nend);

   408 	

   409 	if (pos == string::npos)

   410 	{

   411 		return realstartpos;

   412 	}

   413 	else

   414 	{

   415 		return pos;

   416 	}

   417 }

   418 /*

   419 This function checks the following :

   420 1) Whether the name is in comment scope, name is checked for both C-style comments(or block comments) and C++-style comments(Line Comments)

   421 2) The function name is not a keyword having same program construct as function name(i.e. is not among 'while', 'for','if' and 'for'

   422 

   423 @internalComponent

   424 @released

   425 @param aFile -  Buffer storing the whole source file contents(input)

   426 @param aName -  String that is to be checked whether it lies in the scope of the comment(input)

   427 @param aStartposition - Starting offset of name in file.(input)

   428 @param aStartbraceposn - Starting offset of function block (input)

   429 @param true - if name is in comment scope(output)

   430 @param false - if name is not in comment scope

   431 

   432 

   433 Following patterns are handled in this function:

   434 -----------------------------------------------

   435 NOTE: in order to remove compile warning, i use "|" stand for "/" in this section of comment

   436 

   437 Pattern 1: String is in the scope of both c-style and C++-style comments

   438 		

   439 	|*

   440 	|| name1

   441 	* |

   442 

   443 	

   444 Pattern 2: String is in the scope of both c-style comments

   445 

   446 	|*

   447 		name2()

   448 	* |

   449 			

   450 Pattern 3: String is in comment scope and the comment scope llies in a string

   451 			

   452 	printf(" |*  * | || ")

   453 	

   454 

   455 Pattern 4: String is in the scope of C++-style comments but C-style comments is also available in souurce file	

   456 

   457 	|*

   458 

   459 	* |

   460 

   461 	|| function() 	

   462 		

   463 		

   464 

   465 Pattern 5: String is in the scope of C-style comments but C+++-style comments is also available in souurce file	

   466 		

   467 	|| function() 	

   468 	|*

   469 

   470 	* |

   471 

   472 

   473 Pattern 6: The string is a keyword and the program construct for the keyword is same as for the functions

   474 	for()

   475 	{ } 

   476 

   477 

   478 Pattern 7: Both C-style and C++-style comments are avialable in file and the way of specifying comments 

   479           is complex.(i.e. it is difficult to identify whether it is a C-Style comment or C++-style comment

   480 	  ||*******

   481 	   fun() 

   482 	  |******

   483 		**** | 

   484 	  {}

   485 

   486 */

   487 bool TLeaveScanModel::IsInCommentScopeOrKeyword(const string& aFile, string &aName, uint aStartposition,uint aStartbraceposn)

   488 {

   489 	uint blockCommentStartPosn = aFile.rfind("/*",aStartposition);  // In backward direction

   490 	uint lineCommentStartPosn = aFile.rfind("//",aStartposition);

   491 	uint blockCommentEndPosn = aFile.find("*/", aStartposition); // In forward direction

   492 	uint semicolon = aFile.rfind(";",aStartposition);

   493 	uint isvalidlocationforBlock;

   494 	uint isvalidlocationforLine ;

   495 

   496 	if( (0 == strcmp(aName.c_str(),"if")) || (0 == strcmp(aName.c_str(),"while")) ||

   497 		(0 == strcmp(aName.c_str(),"for"))|| (0 == strcmp(aName.c_str(),"switch")) ||

   498 		(0 == strcmp(aName.c_str(),"defined")))

   499 	{

   500 		return true;

   501 	}

   502 	// There is no comment of any type either block comment or line comment 

   503 	if(blockCommentStartPosn == string::npos && lineCommentStartPosn == string::npos)

   504 	{

   505 		return false;

   506 	}

   507 	// A semiclon exists and semicolon is followed by both (1) the end of block comment scope and (2) the end of line comment scope

   508 	else if((semicolon != string::npos)&& 

   509 		((semicolon > blockCommentEndPosn) && (blockCommentStartPosn < blockCommentEndPosn))  &&

   510 		(semicolon > lineCommentStartPosn))

   511 	{

   512 		return false;

   513 	}

   514 	else if(lineCommentStartPosn == string::npos)

   515 	{

   516 		// Valid Block comment, verify that the function name by applying smartfind

   517 		isvalidlocationforBlock = SmartFind(aFile, aName, blockCommentStartPosn); 

   518 		if( (isvalidlocationforBlock == string::npos) || // There is no occurrence of name

   519 			((isvalidlocationforBlock > aStartbraceposn) && (isvalidlocationforBlock != string::npos))) // The name exists but that is inside function block

   520 		{

   521 			return true; 

   522 		}

   523 		else

   524 		{

   525 			return false; 

   526 		}

   527 	}

   528 	else if(blockCommentStartPosn == string::npos)

   529 	{

   530 		isvalidlocationforLine = SmartFind(aFile,aName, lineCommentStartPosn); 

   531 		if(	(isvalidlocationforLine == string::npos) || // There is no occurrence of name

   532 			((isvalidlocationforLine > aStartbraceposn) && (isvalidlocationforLine != string::npos) ) ) // The name exists but that is inside function block

   533 		{

   534 			return true;

   535 		}

   536 		else

   537 		{

   538 			return false;

   539 		}

   540 	}

   541 	else

   542 	{

   543 		isvalidlocationforBlock = SmartFind(aFile,aName, blockCommentStartPosn); 

   544 		isvalidlocationforLine = SmartFind(aFile,aName, lineCommentStartPosn);

   545 		if((isvalidlocationforLine == string::npos) )

   546 		{

   547 		  return true;

   548 		}

   549 		else if(( (isvalidlocationforLine > aStartbraceposn) && (isvalidlocationforLine != string::npos)) )

   550 		{

   551 		 return true; 

   552 		}

   553 		else if( (0 == isvalidlocationforBlock) || ((isvalidlocationforBlock > aStartbraceposn) && (isvalidlocationforBlock != string::npos)) )

   554 		{

   555 		 return true; 

   556 		}

   557 		else if(( blockCommentStartPosn <  aStartbraceposn) && (blockCommentEndPosn < aStartbraceposn ) && (blockCommentStartPosn < blockCommentEndPosn) && ((isvalidlocationforBlock == string::npos)))

   558 		{

   559 			return true; 

   560 		}

   561 		else

   562 		{

   563 			return false; 

   564 		}

   565 	}

   566 }

   567 

   568 /*

   569 This function checks whether the function name is a macro or not

   570 

   571 @internalComponent

   572 @released

   573 @param aFile - Buffer storing the whole source file contents

   574 @param aStartbraceposn - Starting offset of function block (input)

   575 @param aParenPos - End position of function signature

   576 @param aStartposnofname - Starting offset of string that is to be considered as a function name

   577 @param true - If function name is not a macro

   578 @param false - If function name is a macro  

   579 

   580 Following patterns are handled in this function:

   581 -----------------------------------------------

   582 

   583 Pattern 1: Function is invoked in macro

   584 

   585 	#if defined macro()

   586 	#endif

   587 	struct s1

   588 	{

   589 

   590 	}

   591 

   592 Pattern 2: Function is invoked in macro but the macro itself is in comment scope

   593 	void fun()

   594 	// #if macro()

   595 	// #endif

   596 	{

   597 		struct s1

   598 		{

   599 		

   600 		}

   601 	}

   602   

   603 Pattern 3: There is parameterized Constructor e.g.

   604 

   605 	Foobar(CFileMan* aFileMan) : iFileMan(aFileMan), iCurrentStep(0) {}

   606 

   607 

   608 Pattern 4: Function is defined on the preprocessor statement e.g 

   609 

   610 	#define __KTRACE_ALL(a,p) {if((DEBUGMASK&(a))==(a))p;}

   611 

   612 Pattern 5: All the functions name in comment scope will be ignored

   613 

   614    void func() 

   615 	//	#if comments() 

   616 	{

   617 	 

   618 	}

   619 

   620 Pattern 6: All the functions name (e.g. comments) in comment scope will be ignored

   621   

   622    #if defined()

   623    // comments() 

   624    struct{

   625  	}

   626 

   627 */

   628 

   629 bool TLeaveScanModel::IsFunctionNameStringNotAMacro(const string& aFile, uint aStartbraceposn, uint aParenPos, uint aStartposnofname)

   630 {

   631 	uint startofword = 0;

   632 	uint endofword = 0;

   633 	uint tempParenPos = 0;

   634 	bool posn = true;

   635 	string whiteSpaceChars = " \t\n\r";

   636 	uint tempColonPosn = SmartFind(aFile,":",aParenPos); 

   637 	string  colonString(":");

   638 	bool isColonInCommentScope = IsInCommentScopeOrKeyword(aFile,colonString,aParenPos,aStartbraceposn);

   639 	if(	(tempColonPosn != string::npos)      &&

   640 		(false == isColonInCommentScope)     &&

   641 		(tempColonPosn < aStartbraceposn) )

   642 	{

   643 		return true; // Not a macro

   644 	}

   645 	// The function ignores all the strings which are in the scope of block comments.

   646 	while( startofword < aStartbraceposn && endofword < aStartbraceposn && posn == true)

   647 	{

   648 		if(tempParenPos == 0)

   649 		{

   650 			tempParenPos = aParenPos; // First word

   651 		}

   652 		else

   653 		{

   654 			tempParenPos = endofword; // Next word

   655 		}

   656 		startofword = aFile.find_first_not_of(whiteSpaceChars, tempParenPos+1);

   657 		if(startofword != aStartbraceposn) // No string between function signature and function start block

   658 		{

   659 			// get the posn of word end boundary

   660 			endofword = aFile.find_first_of(whiteSpaceChars, startofword);

   661 			string tmpString = aFile.substr(startofword,endofword-startofword);

   662 			string &aName = tmpString;

   663 			//is throw?

   664 			if(0==aName.find("throw"))

   665 			{

   666 				return true;

   667 			}

   668 			if(	(0 == strcmp(aName.c_str(),"const")) ||

   669 				(0 == strncmp(aName.c_str(),"//",2)) ||

   670 				(0 == strncmp(aName.c_str(),"*/",2)) ||

   671 				(0 == strncmp(aName.c_str(),"/*",2)) )

   672 			{

   673 				// do nothing

   674 			}

   675 			else

   676 			{

   677 				// If string is in comment scope then it is fine i.e. the  function returns true;

   678 				posn = IsInCommentScopeOrKeyword(aFile,aName,startofword,aStartbraceposn);

   679 			}

   680 		}

   681 		else

   682 		{

   683 			//	Pattern 1: only spaces are there between ')' and '{' e.g. void fun() {}

   684 			posn = true;

   685 		}

   686 	}

   687 	if(posn == false)

   688 	{

   689 		return false;

   690 	}

   691 	uint endOfLine=aFile.rfind('\n',aStartposnofname);  // Get the new line position while backtracking 

   692     uint aIndex=(endOfLine==string::npos ? 0 : endOfLine);

   693 	uint preprocessorDirective = aFile.rfind("#",aStartposnofname); // Get the first char of the line starting with #

   694 	if(preprocessorDirective != string::npos && aIndex <= preprocessorDirective)

   695 	{

   696 		return false; // // Yes, the first char is #, so the name on this line can not be a valid function name

   697 	}

   698 	// Check whether it is a macro 

   699 	return true;

   700 }

   701 

   702 

   703 

   704 /*

   705 This function checks whether any semocolon (';') or assignment(=) is encountered 

   706 when the backtracking is done to look for function name. 

   707   

   708 @internalComponent

   709 @released

   710 @param aFile - Buffer storing the whole source file contents

   711 @param aStartbraceposn - Starting offset of function block (input)

   712 @param aTempParenPos - End position of function signature

   713 @param true - if either assignment expression '=' or ':' occurs between function signature and starting curly brace of function block.

   714 @param false - if neither assignment expression '=' nor ':' occurs between function signature and starting curly brace of function block.

   715 

   716 

   717 Following patterns are handled in this function:

   718 -----------------------------------------------

   719 

   720 Pattern 1: The semicolon is encountered while backtracking in the search of function name

   721 

   722 	_LT();

   723 	struct s1

   724 	{

   725 

   726 	}

   727 

   728 Pattern 2: The semicolon is encountered while backtracking in the search of function name

   729 

   730   fun();

   731   a = 2;

   732   struct str1

   733   {

   734   

   735   }

   736 

   737 Pattern 3: The assignment is encountered while backtracking in the search of function name

   738 

   739   voidmain()

   740   a[2] = 

   741   {

   742 	1,2,3

   743   }

   744  

   745 */

   746 

   747 bool TLeaveScanModel::IsSemiColonAndAssignmentOccurs(const string& aFile,uint aStartbraceposn ,uint aTempParenPos)

   748 {

   749 	string  semicolon(";");

   750 	string  assignment("=");

   751 	uint tempSemicolonPosn = SmartFind(aFile,semicolon,aTempParenPos-1); 

   752 	//uint tempAssignMentPosn = SmartFind(aFile,assignment,aTempParenPos-1); 

   753 	bool isSemicolonInCommentScope = IsInCommentScopeOrKeyword(aFile,semicolon,aTempParenPos,aStartbraceposn);

   754 	bool isAssignmentInCommentScope = IsInCommentScopeOrKeyword(aFile,assignment,aTempParenPos,aStartbraceposn);

   755 	if( (tempSemicolonPosn != string::npos)   &&

   756 		((false == isSemicolonInCommentScope) || (false == isAssignmentInCommentScope)) &&

   757 		(tempSemicolonPosn < aStartbraceposn) 

   758 	  )

   759 	{

   760 		return false;

   761 	}

   762 	return true;

   763 }

   764 

   765 /*

   766 This function checks whether the function definition is terminated by semi colon

   767 

   768 If the function definition is terminated with semicolon, then it is

   769 more likely to be a class/struct declaration rather than a function definition.

   770 

   771 @internalComponent

   772 @released

   773 @param aFile - Buffer storing the whole source file contents

   774 @param aStart - Starting offset of the function name string

   775 @return true -  If closing brace corresponding to function names is followed by semicolon 

   776 @return false - If closing brace corresponding to function names is not by semicolon

   777 

   778 Following patterns are handled in this function:

   779 -----------------------------------------------

   780 

   781 Pattern 1: NONSHARABLE_CLASS/NONSHARABLE_STRUCT modifier is used

   782 

   783 	NONSHARABLE_CLASS(...)

   784 	{

   785 

   786 	}; 

   787 

   788 Pattern 2: function definition is terminated by semicolon 

   789 

   790 	aaa(...)

   791 	{

   792 

   793 	} // comment

   794 	; 

   795 

   796 Pattern 3: Class is defined in macro

   797 

   798 	#define MACRO(arg) class name { };

   799 

   800 */

   801 

   802 bool TLeaveScanModel::CheckValidFuncName(const string &aFile, uint aStart)

   803 {

   804   bool returnValue=false;

   805   unsigned long uiNumberOfCurlyBraces = 1;

   806   unsigned int TempPosn = aStart;

   807   unsigned int open_brace = 0;

   808   unsigned int close_brace = 0;

   809   // Continue till than at least any of open curly or close curly brace is remaining

   810   while( !(open_brace == string::npos) || !(close_brace == string::npos) )

   811   {

   812 		  open_brace = SmartFind(aFile, "{", TempPosn+1);

   813 		  close_brace = SmartFind(aFile, "}", TempPosn+1);

   814 

   815 		  if(open_brace < close_brace) // Handle which curly comes first

   816 		  {

   817 			  if((open_brace != string::npos)&& open_brace < aFile.size())

   818 			  {

   819 				uiNumberOfCurlyBraces++; // Update the curly counter

   820 				TempPosn = open_brace;   // move forward to the value from where the search of next curly to be started

   821 			  }

   822 		  }

   823 		  else // close brace comes first

   824 		  {

   825 			  if((close_brace != string::npos)&& close_brace < aFile.size())

   826 			  {

   827 				uiNumberOfCurlyBraces--;

   828 				TempPosn = close_brace; // move forward to the value from where the search of next curly to be started

   829 			  }

   830 			  if(uiNumberOfCurlyBraces == 0) // Match to the corresponding close curly

   831 			  {

   832 				break;

   833 			  }

   834 		  }

   835   }

   836   if(0 == uiNumberOfCurlyBraces)

   837   {

   838 	  string whiteSpaceChars = " \t\n\r";

   839 	  unsigned int braceFollowsSemicolon1 = 0;

   840 	  unsigned int braceFollowsSemicolon2 = 0;

   841 

   842 	  braceFollowsSemicolon1 = SmartFind(aFile, ";", close_brace); // check if any semocolon exists after }

   843 	  braceFollowsSemicolon2 = aFile.find_first_not_of(whiteSpaceChars,close_brace+1); // Get the next character after close_brace

   844 

   845 	  if( (braceFollowsSemicolon1 == braceFollowsSemicolon2) && (braceFollowsSemicolon1 !=  string::npos) &&   (braceFollowsSemicolon2 !=  string::npos))

   846 	  {

   847 	   returnValue = true;

   848 	  }

   849   }

   850 

   851   return returnValue;

   852 }

   853 /*

   854 This function checks whether the function name is specified with template class definition

   855 

   856 @internalComponent

   857 @released

   858 @param nstart - starting offset of the function name string 

   859 @param nend - end offset of the function name string

   860 @return true -  If function name is specified with template class functtion definition

   861 @return false - If function name is not specified with template class functtion definition

   862 

   863 Following patterns are handled in this function:

   864 -----------------------------------------------

   865 

   866 Pattern 1: 

   867 

   868   

   869 template <class T, class S, class L, class R>

   870 GLDEF_C void TestTDes<T,S,L,R>::Test1()

   871 {

   872 	T a(_TL("ABc"));

   873 }

   874 */

   875 

   876 bool TLeaveScanModel::CheckForTemplateFunc(const string& aFile,uint nstart,uint nend)

   877 {

   878 	bool returnValue = false;

   879 	uint OpennAnglebracket = aFile.find_first_of("<", nstart); // advance start

   880 	if(nend == OpennAnglebracket ) // The first invalid char name is <

   881 	{

   882 		uint OpennParen = aFile.find_first_of("(", nstart); // advance start

   883 		uint CloseAnglebracket = SmartFind(aFile, ">::", nstart );

   884 		if( (CloseAnglebracket < OpennParen) && (CloseAnglebracket > OpennAnglebracket))

   885 		{

   886 			returnValue = true;

   887 		}

   888 	}

   889 	return returnValue;

   890 }

   891 

   892 // Seek out mathod functions and return their name and start/end bounds in the

   893 // string file.

   894 //

   895 enum TReturnTypes TLeaveScanModel::GetFunc(const string& aFile, string &aName, uint &start, uint &end)

   896 {

   897   uint nstart = 0;//, cstart = 0;

   898   uint initStart = start;

   899   int realnstart = string::npos;

   900   uint safety = 1000000;

   901   string validNameChars = ":~abcdefghilkjmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_1234567890";

   902   uint prevstart = string::npos;

   903   FOREVER// do // forever 

   904     {

   905 	if(

   906 		(start == string::npos) ||

   907 		(prevstart == start && prevstart != string::npos)

   908 	 )

   909 	{

   910 		return E_False;

   911 	}

   912 	prevstart = start;

   913 

   914       if (safety-- == 0)

   915 	{

   916 	  cout << "ERROR: GetFunc context failure in " << iFileName << "\n";

   917 	  exit(6);

   918 	}

   919 

   920 	// move start along to 'real' double-colon

   921 	uint startColon = SmartFind(aFile, "::", start);

   922 	uint parenPostn = SmartFind(aFile, "(", start + 1);

   923      

   924 	if (startColon == string::npos || startColon >= aFile.length() )

   925 	{

   926 		// Function Definition do not have any :: and function body contains

   927   		nstart = start; 

   928 		// For 1st function, the value of start will be zero and for the

   929 		// second function onwards, it will start after the first function ends

   930 	}

   931 	else

   932 	{

   933 		uint Realstartpost  = GetRealStartPosition(aFile,parenPostn,0);

   934 		// If no real function name exists after double colon

   935 	//	if (Realstartpost == 0)

   936 	//		return E_False;

   937 		uint Realstartopnparen = SmartFind(aFile, "(", Realstartpost + 1); 

   938 

   939 		if(startColon < Realstartopnparen)

   940 		{

   941 			// If the double colon is used for function name then get function name which exists after ::

   942 			nstart = startColon;

   943 			//Get funcName before :: for "La :: La"

   944 			//step1 ':: L...'

   945 			uint fileLen = aFile.length();

   946 			int tmpnstart=nstart+2;

   947 			bool step1 = false;

   948 			while (tmpnstart<fileLen)

   949 			{

   950 				char curChar = aFile[tmpnstart];

   951 				if (curChar==' ' || curChar =='\n' || curChar=='\r' ||curChar=='\t')

   952 				{

   953 					tmpnstart++;

   954 				}

   955 				else if(curChar=='L')

   956 				{

   957 					step1=true;

   958 					break;

   959 				}

   960 				else

   961 				{

   962 					step1 = false;

   963 					break;

   964 				}

   965 			}

   966 			if(step1)

   967 			{

   968 				//step2 L...(<>)? :: L... -->skip all the blank

   969 				bool step2 = true;

   970 				tmpnstart = nstart-1;

   971 				while (tmpnstart>=0)

   972 				{

   973 					char curChar = aFile[tmpnstart];

   974 					if (curChar==' ' || curChar =='\n' || curChar=='\r' ||curChar=='\t')

   975 					{

   976 						tmpnstart--;

   977 					}

   978 					else

   979 					{

   980 						break;

   981 					}

   982 				}

   983 				if(tmpnstart<=0)

   984 				{

   985 					tmpnstart = 0;

   986 					step2 = false;

   987 				}

   988 				else

   989 				{

   990 					char curChar = aFile[tmpnstart];

   991 					if (curChar=='>')

   992 					{

   993 						tmpnstart = GetLeftTmpltParentBack(aFile,tmpnstart-1);

   994 						if(tmpnstart==string::npos)

   995 						{

   996 							//bad pattern

   997 							step2 =false;

   998 						}

   999 						else

  1000 						{

  1001 							tmpnstart --;

  1002 						}

  1003 					}

  1004 					if(tmpnstart==string::npos)

  1005 					{

  1006 						//bad pattern

  1007 						step2 =false;

  1008 					}

  1009 					else

  1010 					{

  1011 						

  1012 						while (tmpnstart>=0)

  1013 						{

  1014 							curChar = aFile[tmpnstart];

  1015 							if (curChar==' ' || curChar =='\n' || curChar=='\r' ||curChar=='\t')

  1016 							{

  1017 								tmpnstart--;

  1018 							}

  1019 							else

  1020 							{

  1021 								break;

  1022 							}

  1023 						}

  1024 						if(tmpnstart <=0) 

  1025 						{

  1026 							tmpnstart=0;

  1027 							step2=false;

  1028 						}

  1029 						while (tmpnstart>=0)

  1030 						{

  1031 							curChar = aFile[tmpnstart];

  1032 							if (curChar=='_' || (curChar>='a' && curChar<='z') || (curChar>='A' && curChar<='Z') ||(curChar>='0' && curChar<='9'))

  1033 							{

  1034 								tmpnstart--;

  1035 							}

  1036 							else

  1037 							{

  1038 								break;

  1039 							}

  1040 						}

  1041 						tmpnstart++;

  1042 						if (tmpnstart<0)

  1043 						{

  1044 							tmpnstart=0;

  1045 							step2=false;

  1046 						}

  1047 						if ( step2 && aFile[tmpnstart]=='L')

  1048 						{

  1049 							realnstart = tmpnstart;

  1050 						}

  1051 					}

  1052 

  1053 				}

  1054 			}

  1055 		}

  1056 		else

  1057 		{

  1058 			// start looking for function name after '('

  1059 			nstart = aFile.find_last_of(validNameChars,parenPostn-1);

  1060 			if(nstart == string::npos)

  1061 				return E_False;

  1062 		}

  1063 	}

  1064     

  1065 	uint semiPos = SmartFind(aFile, ";", nstart + 1); 

  1066 

  1067 	if (semiPos == string::npos || semiPos >= aFile.length())

  1068 		return E_False;

  1069 

  1070 	uint parenPos = SmartFind(aFile, "(", nstart + 1);

  1071     if (parenPos == string::npos || parenPos >= aFile.length()) 

  1072 		return E_False;

  1073 

  1074 	start = SmartFind(aFile, "{", nstart + 1); // advance start

  1075 	if (start == string::npos || start >= aFile.length())

  1076 		return E_False;

  1077 

  1078 	uint nstart2 = SmartFind(aFile, "::", nstart + 1); // next fn

  1079 	// Either (1) Second instance of Double collon is not there and first occurrence of double colon is valid

  1080 	// or (2) second occurrence of double colon is inside the function and first occurrence of double colon is valid

  1081 	

  1082 	if((nstart2 == string::npos && startColon < parenPos && startColon < start)  || ( nstart2 > start && startColon < parenPos && startColon < start ))

  1083 	{

  1084 		// This variable will store the first paranthesis position in a temporary variable

  1085 		// uint TempparenPos = parenPos;

  1086 		uint Realstartpost  = GetRealStartPosition(aFile,parenPos,1 /*To indicate that a valid double colon exists*/);

  1087 	

  1088 		nstart = Realstartpost+1; // reset

  1089 		

  1090 		break;

  1091 	}

  1092 	// Either Second occurrence of Double-colon is invalid  

  1093 	// or Second occurrence of Double-colon exists inside the function 

  1094 	// while first occurrence of double colon is valid

  1095 	else if (nstart2 == string::npos || nstart2 >= aFile.length() || (nstart2 != string::npos && nstart2 > start && startColon < parenPos && startColon < start))

  1096 	{

  1097 		// The opening parenthesis which comes fist after opening brace while moving

  1098  		// in backward direction is a valid candidate for function name.

  1099 		

  1100 		// This variable will store the first paranthesis position

  1101 		uint tempParenPos = aFile.find_last_of('(',start);

  1102 		

  1103 		

  1104 		//void foo() throw () {;}

  1105 		if(tempParenPos != string::npos)

  1106 		{

  1107  			uint throwPos = aFile.find("throw",initStart);

  1108 			if(throwPos!=string::npos && throwPos>=initStart && throwPos<start)

  1109 			{

  1110 					tempParenPos = aFile.find_last_of('(',throwPos);

  1111 					if(tempParenPos==string::npos || tempParenPos<initStart)

  1112 					{

  1113 						tempParenPos = aFile.find_last_of('(',throwPos);

  1114 					}

  1115 			}

  1116 		}

  1117 

  1118 		if (tempParenPos == string::npos)

  1119 		{

  1120 			//FIX this pattern

  1121 			//class A{};

  1122 			//void foo(){fooL();}

  1123 			if(start!=string::npos && semiPos!=string::npos && parenPos!=string::npos&&start<semiPos&&semiPos<parenPos)

  1124 			{

  1125 				start=semiPos+1;

  1126 				return E_Continue;

  1127 			}

  1128 			//FIX this pattern

  1129 			//class B;

  1130 			//class B{};

  1131 			//void foo(){fooL();}

  1132 			else if(start!=string::npos && semiPos!=string::npos && parenPos!=string::npos&&start<parenPos&&semiPos<start)

  1133 			{

  1134 				int tmpRightBracket = GetRightBracket(aFile,start+1);