# #################################################################

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

# All rights reserved.

# 

# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

# 

# * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

# * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

# * Neither the name of Nokia Corporation nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

# 

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 

# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS 

# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 

# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 

# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.#

#

# linescanner.py - the main body of CodeScanner

#

# #################################################################

import base64

import datetime

import encodings

import getopt

import os

import os.path

import psyco

import re

import sys

import xml.dom.minidom

import zlib

# Ignore flags

KIgnoreNothing = 0

KIgnoreComments = 1

KIgnoreCommentsAndQuotes = 2

KIgnoreQuotes = 3

# Severities for the scripts

KSeverityHigh = 0

KSeverityMedium = 1

KSeverityLow = 2

# The names used in the XML configuration file for severity element names.

KSeverityConfigMap = {

			KSeverityHigh		: "high",

			KSeverityMedium		: "medium",

			KSeverityLow		: "low"}

# The names used in the HTML summary file for severity element names.

KSeverityHTMLMap = {

			KSeverityHigh		: "High",

			KSeverityMedium		: "Medium",

			KSeverityLow		: "Low"}

# Categories for the scripts

KCategoryLegal = "Legal Code" 

KCategoryDefinitePanic = "Always Panic"

KCategoryCanPanic = "Can Panic"

KCategoryWrongFunctionality = "Wrong Functionality"

KCategoryLocalisation = "Localisation"

KCategoryPerformance = "Performance"

KCategoryCodingStandards = "Coding Standard"

KCategoryDocumentation = "Documentation"

KCategoryCodeReviewGuides = "Code Review Guide"

KCategoryOther = "Other"

KCategoryHtmlDisplayOrder = [KCategoryLegal,

	KCategoryDefinitePanic,

	KCategoryCanPanic,

	KCategoryWrongFunctionality,

	KCategoryLocalisation,

	KCategoryPerformance,

	KCategoryCodingStandards,

	KCategoryDocumentation,

	KCategoryCodeReviewGuides,

	KCategoryOther]

# The names used in the XML configuration file for category element names.

KCategoryConfigMap = {

			KCategoryLegal				:	"legal", 

			KCategoryDefinitePanic		:	"panic", 

			KCategoryCanPanic			:	"canpanic", 

			KCategoryWrongFunctionality	:	"functionality",

			KCategoryLocalisation		:	"localisation",

			KCategoryPerformance		:	"performance",

			KCategoryCodingStandards	:	"codingstandards",

			KCategoryDocumentation		:	"documentation",

			KCategoryCodeReviewGuides	:	"codereview",

			KCategoryOther				:	"other"}

#Custom rule keyword types

KKeywordBaseClass = "baseclass"

KKeywordCall = "call"

KKeywordClassName = "class"

KKeywordComment = "comment"

KKeywordGeneric = "generic"

KKeywordLocal = "local"

KKeywordMacro = "macro"

KKeywordMember = "member"

KKeywordMethod = "method"

KKeywordParameter = "parameter"

KKeywordUnknown = "unknown"

#The names used in the XML configuration file for custom rule keyword types.

KCustomRuleKeywordMap = {

			KKeywordBaseClass           :   "baseclass",

			KKeywordCall                :   "call",

			KKeywordClassName           :   "class",

			KKeywordComment             :   "comment",

			KKeywordGeneric             :   "generic",

			KKeywordLocal               :   "local",

			KKeywordMacro               :   "macro",

			KKeywordMember              :   "member",

			KKeywordMethod              :   "method",

			KKeywordParameter           :   "parameter",

			KKeywordUnknown             :   "unknown"}

KVersion = "Nokia CodeScanner version 2.1.4"

KCopyrightLine1 = "Copyright (c) 2007-2009. Nokia Corporation. All rights reserved."

KCopyrightLine1Html = "Copyright © 2007-2009. Nokia Corporation. All rights reserved."

KCopyrightLine2 = "For product and support information, visit www.forum.nokia.com."

KWww = "www.forum.nokia.com"

stringPool = {}

#!LOCALISEHERE

def Usage(code, msg=""):

	print msg

	print

	print KVersion

	print

	print "Usage: CodeScanner [options] <source dir> [<output dir>]"	

	print "   or: CodeScanner [options] <source file> [<output dir>]"

	print 

	print "options:"

	print "    -h - display command help"

	print "    -v - display verbose messages"

	print "    -c <config file> - use specified configuration file"

	print "    -i <source dir/file> - specify additional directory/file to scan"

	print "    -l <log file> - create debug log with specified filename"

	print "    -o html|xml|std - specify output format : HTML, XML or StdOut; default is HTML"

	print "    -x url to lxr site"

	print "    -r lxr version"

	print "    -t on/off - create a time-stamped directory for results, default is on"

	print

	print "<source dir> is the directory containing the source code to scan"

	print "<source file> is the single file containing the source code to scan"

	print "<output dir> is the directory in which to produce the output"

	print

	print "Notes:"

	print "<source dir> and <output dir> cannot be identical"

	print "<output dir> cannot be the root of a drive"

	print

	print KCopyrightLine1

	print KCopyrightLine2

	if scanner.iLog <> None:

		scanner.iLog.Write("usage(): exiting with code " + str(code))

		scanner.iLog.Close()

	sys.exit(code)

def DefaultCompare(aLines, aCurrentline, aRematch, aFilename):

	if aRematch.search(aLines[aCurrentline]):

		return 1

	else:

		return 0

def DefaultFuncParamCompare(lines, currentline, rematch, filename):

	# distinguish local declaration from function parameter

    line = lines[currentline]

    m = rematch.search(line)

    if m:

        isFuncParam = (line.find(")") <> -1)

        isLocal = (line.find(";") <> -1)

        while (not isFuncParam) and (not isLocal) and (currentline + 1 < len(lines)):

            currentline += 1

            line = lines[currentline]

            isFuncParam = (line.find(")") <> -1)

            isLocal = (line.find(";") <> -1)

        if isFuncParam:

            return 1

        elif isLocal:

            return 0

    return 0

def ScanDirOrFile(argument):

	if os.path.isdir(argument):

		scanner.iComponentManager.SetRoot(argument)

		scanner.TraverseDirectory(argument)

	elif os.path.isfile(argument):

		parentDir = os.path.dirname(argument)

		scanner.iComponentManager.SetRoot(parentDir)

		scanner.iComponentManager.BeginDirectory(parentDir)

		numberOfLinesScanned = 0

		numberOfLinesScanned += scanner.ScanFile(argument)

		scanner.iComponentManager.EndDirectory(parentDir, numberOfLinesScanned)

	else:

		print "Unable to open specified source file: " + argument

		sys.exit(2)

class CScript:

	# #######################################################

	# CScript - a test script

	def __init__(self, aScriptName):

		self.iScriptName = aScriptName

		self.iCompare = DefaultCompare

		self.iReString = ""

		self.iReMatch = re.compile("")

		self.iTitle = stringPool[aScriptName + "!title"]

		self.iIdeTitle = stringPool[aScriptName + "!ideTitle"]

		self.iFileExts = []

		self.iIgnore = KIgnoreNothing

		self.iDescription = stringPool[aScriptName + "!description"]

		self.iSeverity = KSeverityMedium

		self.iBaseClass = ""

	def ScriptConfig(self):

		if (scanner.iDomConfig <> None):

			for scriptsNode in scanner.iDomConfig.getElementsByTagName("scripts"):

				for scriptNode in scriptsNode.getElementsByTagName(self.iScriptName):

					return scriptNode

		return None

	def DefaultInheritanceCompare(self, lines, currentline, rematch, filename):

		m = rematch.search(lines[currentline])

		if m:

			inheritanceString = m.group(3)

			# check for inheritance list spanning multiple lines

			i = currentline + 1

			while (inheritanceString.find("{") == -1) and i < len(lines):

				if (inheritanceString.find(";") <> -1):

					return 0

				inheritanceString += lines[i]

				i += 1

			# construct inheritance class list

			inheritancelist = inheritanceString.split(",")

			reclass = re.compile("[\s:]*(public|protected|private)?\s*([\w:]+)")

			classlist = []

			for inheritance in inheritancelist:

				match = reclass.search(inheritance)

				if match:

					inheritclass = match.group(2)

					colonpos = inheritclass.rfind(":")

					if (colonpos <> -1):

						inheritclass = inheritclass[colonpos + 1:]

					classlist.append(inheritclass)

			# search for inheritance class

			for classname in classlist:

				if classname == self.iBaseClass:

					return 1

		return 0

class CCustomScript(CScript):

	# #######################################################

	# CScript - a test script based on a custom rule

	def __init__(self, aScriptName):

		self.iScriptName = aScriptName

		self.iCompare = DefaultCompare

		self.iReString = ""

		self.iTitle = ""

		self.iIdeTitle = ""

		self.iFileExts = []

		self.iIgnore = KIgnoreNothing

		self.iDescription = ""

class CCategorisedScripts:

	# #######################################################

	# CCategorisedScripts - a collection of scripts sorted

	# by script category (panic, can panic, etc.)

	def AddScript(self, aScript):

		# do we have a category for this already?

		category = aScript.iCategory

		if (not self.iScripts.has_key(category)):

			# no, create a linear array here

			self.iScripts[category] = []

		# append to the correct category

		self.iScripts[category].append(aScript)

		# compile the reg-ex otherwise will get continuous hits

		aScript.iReMatch = re.compile(aScript.iReString, re.VERBOSE)

	def AllScripts(self):

		result = []

		for scripts in self.iScripts.values():

			result += scripts

		return result

	def PrintListOfTestScripts(self):

		for category in self.iScripts.keys():

			print(category + "\n----------------------------------")

			for script in self.iScripts[category]:

				print("\t" + script.iScriptName)

		print("")

	# iScripts is a 2D array, 1st level is a hash of categories

	#                         2nd level is linear array

	iScripts = {}        

class CLogger:

	# #######################################################

	# CLogger

	# a simple log file interface

	def __init__(self, aFilename):

		if aFilename != None and len(aFilename) > 0:

			self.iFile = file(aFilename, "w")

			self.iFile.write(KVersion + " started at " + datetime.datetime.now().ctime() + "\n")

		else:

			self.iFile = None

	def Write(self, aText):

		if self.iFile <> None:

			self.iFile.write(str(datetime.datetime.now().time())+":"+aText+"\n")

			self.iFile.flush()

	def Close(self):

		if self.iFile <> None:

			self.iFile.write(KVersion + " ended at " + datetime.datetime.now().ctime() + "\n")

			self.iFile.close()

class CRendererBase:

	# #######################################################

	# CRendererBase - base class for renderers

	def RegisterSelf(self, aName, aDescription, aRendererManager):

		self.iName = aName

		self.iDescription = aDescription

		aRendererManager.AddRenderer(self)

	def BeginComponent(self, aComponent):

		return

	def BeginFile(self, aFilename):

		return

	def ReportError(self, aLineContext, aScript):

		return

	def EndFile(self):

		return

	def EndComponent(self, aComponent):

		return

class CStdOutRenderer(CRendererBase):

	# #######################################################

	# CStdOutRenderer - renderer for Standard Console Output

	# Output goes to standard output; when run in Carbide, 

	# this shows up in the output window. Correctly formatted 

	# lines can then be selected, automatically selecting 

	# the corresponding line of the associated source file. 

	# The format is:

	#   <filename>(<line>) : <comment>

	def __init__(self, aRendererManager):

		self.RegisterSelf("stdout", "StdOut renderer", aRendererManager)

		print KVersion

	def BeginComponent(self, aComponent):

		return

	def BeginFile(self, aFilename):

		self.iErrorCount = 0

		scanner.ReportAction("Scanning file " + aFilename)

	def ReportError(self, aLineContext, aScript):

		self.iErrorCount += 1

		if (aScript.iSeverity == KSeverityLow):

			msgType = "info"

		elif (aScript.iSeverity == KSeverityMedium):

			msgType = "warning"

		elif (aScript.iSeverity == KSeverityHigh):

			msgType = "error"

		print(aLineContext.iFileName + "(" + str(aLineContext.iLineNumber) + ") : " + msgType + ": " + aScript.iScriptName + ": " + KSeverityConfigMap[aScript.iSeverity] + ": " + KCategoryConfigMap[aScript.iCategory] + ": " + aScript.iIdeTitle)

		if len(scanner.iRendererManager.iAnnotation)>0:

			print scanner.iRendererManager.iAnnotation

			scanner.iRendererManager.iAnnotation = ""

	def EndFile(self):

		scanner.ReportAction("Total problems found in file: " + str(self.iErrorCount))

	def EndComponent(self, aComponent):

		scanner.iEndTime = datetime.datetime.now().ctime()

		return

class CXmlComponentSummaryFile:

	# #########################################################

	# CXmlComponentSummaryFile

	# Encapsulates the script (problem) summary for XML output.

	# For each script, there is a listing for occurrences

	# of that script's problem and location of each occurrence.

	def CreateSummary(self, aXmlRenderer):

		try:

			outputPath = os.path.normpath(os.path.join(aXmlRenderer.iOutputDirectory, "problemIndex.xml"))

			outputFile = file(outputPath, "w")

		except IOError:

			scanner.ReportError("IOError : Unable to create output file " + outputPath)

		else:

			errors = aXmlRenderer.iErrors

			level = 0

			indent = "   "

			outputFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")

			outputFile.write(level * indent + "<problemIndex>\n")

			level += 1

			for category in KCategoryHtmlDisplayOrder:

				found = False

				if scanner.iCategoriedScripts.iScripts.has_key(category):

					for script in scanner.iCategoriedScripts.iScripts[category]:

						if errors.has_key(script.iScriptName):

							found = True

							break

					if found:

						outputFile.write(level * indent + "<category")

						outputFile.write(" name=\"" + KCategoryConfigMap[category] + "\">\n")

						level += 1

						for script in scanner.iCategoriedScripts.iScripts[category]:

							if errors.has_key(script.iScriptName):

								outputFile.write(level * indent + "<problem")

								outputFile.write(" name=\"" + script.iScriptName + "\"")

								outputFile.write(" severity=\"" + KSeverityConfigMap[script.iSeverity] + "\">\n")

								level += 1

								for fileName, lines in errors[script.iScriptName].items():

									outputFile.write(level * indent + "<file")

									outputFile.write(" path=\"" + fileName + "\">\n")

									level += 1

									for lineNo in lines:

										outputFile.write(level * indent + str(lineNo) + "\n")

									level -= 1

									outputFile.write(level * indent + "</file>\n")

								level -= 1

								outputFile.write(level * indent + "</problem>\n")

						level -= 1

						outputFile.write(level * indent + "</category>\n")

			level -= 1

			outputFile.write(level * indent + "</problemIndex>\n")

			outputFile.close()

class CXmlRenderer(CRendererBase):

	# ########################################

	# CXmlRenderer - a renderer for XML output

	def __init__(self, aRendererManager, aOutputDirectory):

		self.RegisterSelf("xml", "XML renderer", aRendererManager)

		self.iOutputDirectory = aOutputDirectory

		if os.path.isdir(self.iOutputDirectory) != True :

			os.makedirs(self.iOutputDirectory)

		self.iErrors = {} 

		print

		print KVersion

		print KCopyrightLine1

		print KCopyrightLine2

	def BeginComponent(self, aComponent):

		return

	def BeginFile(self, aFilename):

		self.iFilename = aFilename

		scanner.ReportAction("Scanning file " + aFilename)

	def ReportError(self, aLineContext, aScript):

		scriptName = aScript.iScriptName

		fileName = aLineContext.iFileName

		lineNumber = aLineContext.iLineNumber

		if (not self.iErrors.has_key(scriptName)):

			self.iErrors[scriptName] = {}

		if (not self.iErrors[scriptName].has_key(fileName)):

			self.iErrors[scriptName][fileName] = []

		self.iErrors[scriptName][fileName].append(lineNumber)

	def EndFile(self):

		#tbd

		return

	def EndComponent(self, aComponent):

		relativeComponentName = scanner.iComponentManager.RelativeComponentName(aComponent.iFullPath)

		if len(relativeComponentName) < 1:	# root component - final component

			scanner.iEndTime = datetime.datetime.now().ctime()

			componentSummaryFile = CXmlComponentSummaryFile()

			componentSummaryFile.CreateSummary(self)

class CHtmlOutputFileBase:

	# #######################################################

	# CHtmlOutputFileBase - base class for HTML output files

	def WriteHeader(self, aOutputFile):

		aOutputFile.write("<html><body>")

	def Write(self, aOutputFile, aText):

		aOutputFile.write(aText)

	def WriteLink(self, aOutputFile, aHref, aText):

		aHref = self.CleanupLink(aHref)

		aOutputFile.write("<a href=\"" + aHref + "\">" + aText + "</a>")

	def WriteElement(self, aOutputFile, aElementName, aElementValue):

		aOutputFile.write("<"+aElementName+">"+aElementValue+"</"+aElementName+">")

	def WriteBreak(self, aOutputFile):

		aOutputFile.write("<br>")

	def WriteFooter(self, aOutputFile):

		aOutputFile.write("<br><hr><center><h5>"+KCopyrightLine1Html+"</h5>")

		aOutputFile.write("<h5>")

		CHtmlOutputFileBase.WriteLink(self, aOutputFile, "http://"+KWww, KWww)

		aOutputFile.write("</h5></center></body></html>")