#

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

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of the License "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: 

# Filter class for filtering XML logs and generating reports

# Prints errors and warnings to stdout

#

import sys

import raptor

import filter_interface

import generic_path

import os

import os.path

import re

class Recipe(object):

	"""State machine that parses a recipe

	"""

	suppress = []

	warningRE = re.compile("^.*((Warning:)|(MAKEDEF WARNING:)) .*$", re.DOTALL | re.M | re.I)

	infoRE = None

	name = [ "default" ]

	recipes = []

	def __init__(self, text):

		self.suppress = self.__class__.suppress

		self.text = text

		self.warningRE = Recipe.warningRE

	def warnings(self):

		return self.warningRE.findall(self.text)

	def info(self):

		if self.infoRE:

			return self.infoRE.findall(self.text)

		else:

			return []

	@classmethod			

	def factory(cls, name, text):

		for r in Recipe.recipes:

			if name in r.name:

				return r(text)

		return Recipe(text)

class MwLinkerRecipe(Recipe):

	suppress = [ 

		re.compile(

r"^mwldsym2: warning: Cannot locate library \"MSL_All_Static_MSE_Symbian\" specified in #pragma comment\(lib,...\)$"

r"[\n\r]*mwldsym2: warning: referenced from.*$"

r"[\n\r]*mwldsym2: warning: Option 'Use default libraries' is enabled but linker used.*$"

r"[\n\r]*mwldsym2: warning: runtime library from MW\[...\]LibraryFiles \(msl_all_static_mse_symbian_d.lib\);$"

r"[\n\r]*mwldsym2: warning: this indicates a potential settings/libraries mismatch.*$"

		, re.M)

		, re.compile(

r"^mwldsym2.exe: warning: Multiply defined symbol: ___get_MSL_init_count in.*$"

r"[\n\r]*mwldsym2.exe: warning: files uc_cwhelp.obj \(.*\), startup.win32.c.obj \(msl_all_static_mse_symbian_d.lib\),.*$"

r"[\n\r]*mwldsym2.exe: warning: keeping definition in startup.win32.c.obj.*$"

		, re.M )

		, re.compile(

r"^mwldsym2.exe: warning: Option 'Use default libraries' is enabled but linker used.*$"

r"[\n\r]*mwldsym2.exe: warning: runtime library from MW\[...\]LibraryFiles \(msl_all_static_mse_symbian_d.lib\);.*$"

r"[\n\r]*mwldsym2.exe: warning: this indicates a potential settings/libraries mismatch.*$"

	, re.M)

	]

	name = [ "win32stagetwolink", "win32simplelink" ]

	def warnings(self):

		edited = self.text

		for s in MwLinkerRecipe.suppress:

			edited = s.sub("", edited)

		return Recipe.warningRE.findall(edited)

Recipe.recipes.append(MwLinkerRecipe)

class FreezeRecipe(Recipe):

	name = [ "freeze" ]

	warningRE = re.compile("^(WARNING:) .*$", re.DOTALL | re.M | re.I)

	infoRE = re.compile("^(EFREEZE:) .*$", re.DOTALL | re.M | re.I)

	def __init__(self, text):

		Recipe.__init__(self, text)

		self.warningRE = FreezeRecipe.warningRE

		self.infoRE = FreezeRecipe.infoRE

Recipe.recipes.append(FreezeRecipe)

class FilterTerminal(filter_interface.Filter):

	attribute_re = re.compile("([a-z][a-z0-9]*)='([^']*)'",re.I)

	maxdots = 40 # if one prints dots then don't print masses

	recipelinelimit = 1024 # don't scan ultra-long recipes in case we run out of memory

	# recipes that we think most users are interested in

	# and the mapping that we will use to output them as

	docare = {

		"asmcompile" : "asmcompile" ,

		"compile" : "compile" ,

		"postlink" : "target",

		"linkandpostlink" : "target",

		"resourcecompile" : "resource",

		"genstringtable" : "strtable",

		"tem" : "tem",

		"bitmapcompile" : "bitmap",

		"bitmapcopy" : "bitmapcopy",

		"win32compile2object" : "compile",

		"win32stagetwolink" : "target",

		"win32simplelink" : "target",

		"tools2install" : "target",

		"compile2object" : "compile",

		"msvctoolsinstall" : "target",

		"msvctoolscompile" : "compile",

		"freeze" : "freeze",

		"win32archive" : "target"

	}

	# Determine the width of the largest mapped recipe name

	recipewidth = 0

	for i in docare:

		l = len(docare[i])

		if l > recipewidth:

			recipewidth = l # justification for printing out recipes.

	recipewidth+=1

	def __init__(self):

		self.analyseonly = False

		self.quiet = False

		# defaults can use EPOCROOT

		if "EPOCROOT" in os.environ:

			self.epocroot = str(generic_path.Path(os.environ["EPOCROOT"]))

		else:

			self.epocroot = str(generic_path.Path('/'))

		self.current_recipe_logged = False

		self.cleaned = 0  # cleaned files

		self.dotcount = 0 # progress dots printed so far

		# list of strings to catch make errors (must be lowercase)

		self.make_error_expr = set([

				"error:",

				": ***",

				"make: interrupt/exception caught (code =",

				"make.exe: interrupt/exception caught (code ="

				])

		# list of strings to catch make warnings (must be lowercase)

		self.make_warning_expr = ["warning:"]

		# list of strings to catch recipe warnings (must be lowercase)

		self.recipe_warning_expr = ["warning:"]

	def isMakeWarning(self, text):

                """A simple test for warnings.

                Can be extended do to more comprehensive checking."""

		# generic warnings checked

		# array of make_warning_expr holds all the possible values

		for warn in self.make_warning_expr:

			if warn in text.lower():

				return True

		return False

	def isMakeError(self, text):

		"""A simple test for errors.	

		Can be extended to do more comprehensive checking."""

		# make, emake and pvmgmake spit out things like

		# make: *** No rule to make target X, needed by Y. Stop.

		#

		# array of make_error_expr holds all the possible values

		for err in self.make_error_expr:

			if err in text.lower():

				return True

		return False

	def open(self, raptor_instance):

		"""Set output to stdout for the various I/O methods to write to."""

		self.raptor = raptor_instance

		# Be totally silent?

		if self.raptor.logFileName is None:

			self.analyseonly = True

		# Only print errors and warnings?

		if self.raptor.quiet:

			self.quiet = True

		# keep count of errors and warnings

		self.err_count = 0

		self.warn_count = 0

		self.suppressed_warn_count = 0

		self.inBody = False

		self.inRecipe = False

		return True

	def write(self, text):

		"""Write errors and warnings to stdout"""

		if text.startswith("<error"):

			start = text.find(">")

			end = text.rfind("<")

			self.err_count += 1

			if not self.analyseonly:

				sys.stderr.write(str(raptor.name) + ": error: %s\n" \

						% text[(start + 1):end])

		elif text.startswith("<warning"):

			start = text.find(">")

			end = text.rfind("<")

			self.warn_count += 1

			if not self.analyseonly:

				sys.stdout.write(str(raptor.name) + ": warning: %s\n" \

					% text[(start + 1):end])

		elif text.startswith("<status "):

			# detect the status report from a recipe

			if text.find('failed') != -1:

				self.failed = True

				if text.find("reason='timeout'") != -1:

					self.timedout = True

			else:

				self.failed = False

			return

		elif text.startswith("<recipe "):

			# detect the start of a recipe

			if self.inRecipe:

				sys.stdout.flush()

				sys.stderr.write(self.formatError("Opening recipe tag found " \

						+ "before closing recipe tag for previous recipe:\n" \

						+ "Discarding previous recipe (Possible logfile " \

						+ "corruption)"))

				sys.stderr.flush()

			self.inRecipe = True

			self.current_recipe_logged = False

			m = FilterTerminal.attribute_re.findall(text)

			self.recipe_dict = dict ()

			for i in m:

				self.recipe_dict[i[0]] = i[1]

			# Decide what to tell the user about this recipe

			# The target file or the source file?  

			name = None

			if 'source' in self.recipe_dict:

				name = self.recipe_dict['source']

			name_to_user = ""

			# Make source files relative to the current directory if they are 

		 	# not generated files in epocroot.  Also make sure path is in 

			# the appropriate format for the user's shell.

			if name and (name.find("epoc32") == -1 or name.endswith('.UID.CPP')):

				for i in name.rsplit():

					name_to_user += " " + generic_path.Path(i).From(generic_path.CurrentDir()).GetShellPath()

			else:

				# using the target.  Shorten it if it's in epocroot by just chopping off

				# epocroot

				name_to_user = self.recipe_dict['target']

				if name_to_user.find(self.epocroot) != -1:

					name_to_user = name_to_user.replace(self.epocroot,"")

					if name_to_user.startswith('/') or name_to_user.startswith('\\'):

						name_to_user = name_to_user[1:]

				name_to_user = generic_path.Path(name_to_user).GetShellPath()	

			self.recipe_dict['name_to_user'] = name_to_user

			self.recipe_dict['mappedname'] = self.recipe_dict['name'] 

			# Status message to indicate that we are building

			recipename = self.recipe_dict['name']

			if recipename in FilterTerminal.docare:

				self.recipe_dict['mappedname'] = FilterTerminal.docare[recipename]

				self.logit_if()

			# This variable holds all recipe information

			self.failed = False # Recipe status

			self.timedout = False # Did it Timeout?

			self.recipeBody = []

			self.recipelineExceeded = 0

			return		

		elif text.startswith("</recipe>"):

			# detect the end of a recipe

			if not self.inRecipe:

				sys.stdout.flush()

				sys.stderr.write(self.formatError("Closing recipe tag found " \

						+ "before opening recipe tag:\nUnable to print " \

						+ "recipe data (Possible logfile corruption)"))

				sys.stderr.flush()

			else:

				self.inRecipe = False

				if self.failed == True:

					if not self.analyseonly:

						reason=""

						if self.timedout:

							reason="(timeout)"

						sys.stderr.write("\n FAILED %s %s for %s: %s\n" % \

								(self.recipe_dict['name'],

								reason,

								self.recipe_dict['config'],

								self.recipe_dict['name_to_user']))

						mmppath = generic_path.Path(self.recipe_dict['mmp']).From(generic_path.CurrentDir()).GetShellPath()

						if mmppath is not "":

							sys.stderr.write("  mmp: %s\n" % mmppath)

						if self.timedout:

							sys.stderr.write( \

"""    Timeouts may be due to network related issues (e.g. license servers),

    tool bugs or abnormally large components. TALON_TIMEOUT can be adjusted 

    in the make engine configuration if required.  Make engines may have 

    their own timeouts that Raptor cannot influence

""")

						else:

							for L in self.recipeBody:

								if not L.startswith('+'):

									sys.stdout.write("   %s\n" % L.rstrip())

					self.err_count += 1

				else:

					r = Recipe.factory(self.recipe_dict['name'], "".join(self.recipeBody))

					warnings = r.warnings()

					info = r.info()

					if len(warnings) or len(info):

						if not self.analyseonly:

							for L in self.recipeBody:

								if not L.startswith('+'):

									sys.stdout.write("   %s\n" % L.rstrip())

						self.warn_count += len(warnings)

				self.recipeBody = []

			return

		elif not self.inRecipe and self.isMakeError(text):

			# these two statements pick up errors coming from make

			self.err_count += 1

			sys.stderr.write("    %s\n" % text.rstrip())

			return

		elif not self.inRecipe and self.isMakeWarning(text):

			self.warn_count += 1

			sys.stdout.write("    %s\n" % text.rstrip())

			return

		elif text.startswith("<![CDATA["):

                	# save CDATA body during a recipe

			if self.inRecipe:

				self.inBody = True

		elif text.startswith("]]>"):

			if self.inRecipe:

				self.inBody = False

				if self.recipelineExceeded > 0:

					self.recipeBody.append("[filter_terminal: OUTPUT TRUNCATED: " + \

						"Recipe output limit exceeded; see logfile for full output " + \

						"(%s lines shown out of %s)]" % (FilterTerminal.recipelinelimit, \

						FilterTerminal.recipelinelimit + self.recipelineExceeded))

		elif text.startswith("<info>Copied"):

			if not self.analyseonly and not self.quiet:

				start = text.find(" to ") + 4

				end = text.find("</info>",start)

				short_target = text[start:end]

				if short_target.startswith(self.epocroot):

					short_target = short_target.replace(self.epocroot,"")[1:]

				short_target = generic_path.Path(short_target).GetShellPath()

				sys.stdout.write(" %s: %s\n" % ("export".ljust(FilterTerminal.recipewidth), short_target))

			return

		elif text.find("<rm files") != -1 or text.find("<rmdir ") != -1:

			# search for cleaning output but only if we 

			# are not in some recipe (that would be pointless)

			if not self.analyseonly and not self.quiet:

				if  self.cleaned == 0:

					sys.stdout.write("\ncleaning ")

					self.cleaned+=1

				elif self.dotcount < FilterTerminal.maxdots:

					if self.cleaned % 5 == 0:

						self.dotcount+=1

						sys.stdout.write(".")

					self.cleaned+=1

				return

		elif self.inBody:

			# We are parsing the output from a recipe

			# we have to keep the output until we find out

			# if the recipe failed. But not all of it if it turns

			# out to be very long

			if len(self.recipeBody) <= FilterTerminal.recipelinelimit:

				self.recipeBody.append(text)

			else:

				self.recipelineExceeded += 1

	def logit(self):

		""" log a message """

		info = self.recipe_dict['mappedname'].ljust(FilterTerminal.recipewidth)

		config = self.recipe_dict['config']

		name = self.recipe_dict['name_to_user'].lstrip()

		# If its a multifile config, we print source files one below the other in a single

		# 'compile:' statement

		if config.endswith('multifile'):

			files =  self.recipe_dict['name_to_user'].split()

			name = ""

			for i in files:

				if i == files[0]:

					name +=  i

				else:

					name +=  '\n\t      ' + i

		sys.stdout.write(" %s: %s  \t[%s]\n" % (info, name, config))

	def logit_if(self):

		""" Tell the user about the recipe that we are processing """

		if not self.analyseonly and not self.quiet:

			if self.inRecipe and not self.current_recipe_logged:

				self.logit()

				self.current_recipe_logged = True

	def summary(self):

		"""Errors and warnings summary"""

		if self.raptor.skipAll or self.analyseonly:

			return

		if self.cleaned != 0:

			sys.stdout.write("\n\n")

		if self.warn_count > 0 or self.err_count > 0:

			sys.stdout.write("\n%s : warnings: %s\n" % (raptor.name,

					self.warn_count))

			sys.stdout.write("%s : errors: %s\n" % (raptor.name,

					self.err_count))

		else:

		sys.stdout.write("\nRun time %d seconds\n" % self.raptor.runtime);

		sys.stdout.write("\n")

		return True

	def close(self):

		"""Tell raptor that there were errors."""

		if self.err_count > 0:

			return False

		return True