// Copyright (c) 1997-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:

// Limitations:

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

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

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

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

// in possible unreported problems.

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

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

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

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

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

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

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

// check the version and cater for enhanced behaviour.

// Local Version:

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

// 

//

#include <fstream>

#include <iostream>

#include <sstream>   

#include <string>

#include <assert.h>

#include <list>

#define FOREVER for(;;)

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

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

// Shorthand

typedef unsigned int uint;

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

enum TMatchTypes { 

  E_LCleanedUp=0,

  E_LString,

  E_LManaged,

  E_LData,

  E_Ell , 

  E_Trap, 

  E_BlockComment, 

  E_LineComment, 

  E_Eleave, 

  E_UserEleave, 

  E_String,

  E_Quote,

  E_OpenBrace,

  E_CloseBrace,

  E_OrLeave,

  E_Last };

// Set of return values of GetFunc().

enum TReturnTypes {

  E_False = 0,

  E_True,

  E_Continue };

enum TPPState { 

   PPSTATE_NORMAL=0,

   PPSTATE_ESCAPED_LINE ,

   PPSTATE_SINGLE_COMMENT,

   PPSTATE_MUL_COMMENT,

   PPSTATE_STRING_LITERAL,

   PPSTATE_SHARP_COMMENT

  };

enum TClassMemberTypes { 

    E_NA= 0, 

    E_MemberData, 

    E_MemberFunctionDecl, 

    E_MemberFunctionDef, 

    E_Enum

    };

using namespace std;

struct ClassMeta {

	 string className ;

	 int startPos;

	 int endPos;

};

class TLeaveScanModel

{

public:

  bool  Scan(ifstream& aStream);

  void  SetFileName(char* aName);

  char* FileName();

  int   Verbose;

  bool OnlyPrePrecess;

private:	

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

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

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

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

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

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

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

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

  void  Peek(const string aStr, uint aPos);

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

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

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

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

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

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

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

  uint  FindFirstMatchType(uint aMatchSet[]);

  string PreProcess(const string& aFile);

  string CombineLine(const string& aFile);

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

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

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

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

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

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

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

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

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

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

  bool IsLClassCtor(const string& aName);

  bool IsInClassScope(uint pos);

  string GetFunctNameFromFuncHead(const string& aFuncHead);

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

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

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

  string GetClassName(uint aStart);

  void  ReportErrorLineAndString(uint aStart);

  bool  AppendCommentToErrorString(uint aEnd);

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

  void  Test1();

  void  Test2L();

  void  Test3();

  void  Test4();

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

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

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

  inline string TrimString(const string& aStr)

  {

	string result = aStr;

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

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

	return result;

  }

private:

  string	iText;

  string	iBody;

  string	iErrorString;

  list<ClassMeta> iClassList;

  int	        iPositionOfError;

  char*         iFileName;

};

void pversion()

{

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

}

void pusage()

{

  pversion();

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

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

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

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

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

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

}

int main(int argc, char** argv)

{

  int noisy = 0;

  bool onlyPreProcess =false;

  if (argc < 2)

    {

      pusage();

      return 1;

    }

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

    {

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

	{

	  switch(argv[clparam][1])

	    {

	    case 'n':

	      noisy = 1;

	      break;

	    case 'N':

	      noisy = 2;

	      break;

	    case 'h':

	      pusage();

	      break;

	    case 'v':

	      pversion();

	      break;

	    case 'E':

	    	{

	    		onlyPreProcess = true;

	    	}

	      break;

	    default:

	      pusage();

	      break;

	    }

	} //if

      else

	{

	  // invoked once per file

	  TLeaveScanModel model;

	  model.SetFileName(argv[clparam]);

	  model.Verbose = noisy;

	  if(onlyPreProcess)

	  {

		  model.OnlyPrePrecess = true;

	  }

	  else

	  {

		  model.OnlyPrePrecess = false;

	  }

	  ifstream file(model.FileName());

	  (void) model.Scan(file);

	  file.close();

	  //	  return 0;

	}

    }

  return 0;

}

void TLeaveScanModel::SetFileName(char *aName)

{

  iFileName = aName;

}

char* TLeaveScanModel::FileName()

{

  return iFileName;

}

//

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

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

// located.

bool TLeaveScanModel::Scan(ifstream& aStream)

{

  FileToText(aStream, iText);

  string oldText(iText);

  iText = PreProcess(iText);

  if(OnlyPrePrecess)

	  {

	  	cout<<iText;

	  	return false;

	  }

  if(!iText.length())

    {

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

      return false;

    }

  uint start  = 0;

  uint end    = 0;

  bool isLeaver;

  enum TReturnTypes getFuncReturnTypes;

  //init class list

  iClassList = GetClass(iText);

  //check function

  while (start < iText.length())

    {

      string name;

	  getFuncReturnTypes = E_Continue;

	  while(getFuncReturnTypes == E_Continue)

	  {

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

	  }

      if (!getFuncReturnTypes)

		break;

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

      bool isLCFunc =false;

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

      {

    	  isLCFunc = true;

      }

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

      {

    	  if (clean)

    	  {

    		  iPositionOfError=0;

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

    		  if(!IsInClassScope(start))

			  {

				  ReportErrorLineAndString(start);	  

			  }

    	  }

    	  else if(isLCFunc)

    	  {

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

			  if(lcleanedupPos!=string::npos)

				{

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

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

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

				  {;}

				  else

				  {

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

    	    		if(!IsInClassScope(start))

					{

						ReportErrorLineAndString(start);	  

					}

				  }

				}

    	  }

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

      }

      else // wasn't a leaving container 

      {

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

    		  if(!IsInClassScope(start))

			  {

				  ReportErrorLineAndString(start);	  

			  }

      }

      start = end;

    }

  //check class 

  list<ClassMeta>::iterator iter; 

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

  { 

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

  } 

  return true;

}

//

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

//

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

{

  char data[1024];

  int len;

  do	

    {

      aStream.read(data,1024);

      len = aStream.gcount();

      aText.append(data, len);

    }

  while(len);

}

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

//

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

{

	uint realstartpos = 0;

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

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

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

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

	{

		return realstartpos;

	}

	// This variable will store the first paranthesis position

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

	if (tempParenPos == string::npos)

	{

		// No '(' found yet

		return realstartpos;

	}

	if (aIsvaliddoublecolon == 1)

	{ 

		tempParenPos = aStart;	

	}

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

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

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

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

	if (pos == string::npos)

	{

		return realstartpos;

	}

	else

	{

		return pos;

	}

}

/*

This function checks the following :

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)

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'

@internalComponent

@released

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

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

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

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

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

@param false - if name is not in comment scope

Following patterns are handled in this function:

-----------------------------------------------

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

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

	|*

	|| name1

	* |

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

	|*

		name2()

	* |

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

	printf(" |*  * | || ")

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

	|*

	* |

	|| function() 	

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

	|| function() 	

	|*

	* |

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

	for()

	{ } 

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

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

	  ||*******

	   fun() 

	  |******

		**** | 

	  {}

*/

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

{

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

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

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

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

	uint isvalidlocationforBlock;

	uint isvalidlocationforLine ;

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

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

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

	{

		return true;

	}

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

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

	{

		return false;

	}

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

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

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

		(semicolon > lineCommentStartPosn))

	{

		return false;

	}

	else if(lineCommentStartPosn == string::npos)

	{

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

		isvalidlocationforBlock = SmartFind(aFile, aName, blockCommentStartPosn); 

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

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

		{

			return true; 

		}

		else

		{

			return false; 

		}

	}

	else if(blockCommentStartPosn == string::npos)