#

# Copyright (c) 2007-2009 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: 

# This module includes classes that process bld.inf and .mmp files to

# generate Raptor build specifications

#

import copy

import re

import os.path

import shutil

import stat

import hashlib

import base64

import raptor

import raptor_data

import raptor_utilities

import raptor_xml

import generic_path

import subprocess

import zipfile

from mmpparser import *

import time

PiggyBackedBuildPlatforms = {'ARMV5':['GCCXML']}

PlatformDefaultDefFileDir = {'WINSCW':'bwins',

				  'ARMV5' :'eabi',

				  'ARMV5SMP' :'eabi',

				  'GCCXML':'eabi',

				  'ARMV6':'eabi',

				  'ARMV7' : 'eabi',

				  'ARMV7SMP' : 'eabi'}

def getVariantCfgDetail(aEPOCROOT, aVariantCfgFile):

	"""Obtain pertinent build related detail from the Symbian variant.cfg file.

	This variant.cfg file, usually located relative to $(EPOCROOT), contains:

	(1) The $(EPOCROOT) relative location of the primary .hrh file used to configure the specific OS variant build

	(2) A flag determining whether ARMV5 represents an ABIV1 or ABIV2 build (currently unused by Raptor)."""

	variantCfgDetails = {}

	variantCfgFile = None

	try:

		variantCfgFile = open(str(aVariantCfgFile))

	except IOError, (number, message):

		raise MetaDataError("Could not read variant configuration file "+str(aVariantCfgFile)+" ("+message+")")

	for line in variantCfgFile.readlines():

		if re.search('^(\s$|\s*#)', line):

			continue

		# Note that this detection of the .hrh file matches the command line build i.e. ".hrh" somewhere

		# in the specified line

		elif re.search('\.hrh', line, re.I):

			variantHrh = line.strip()

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

				variantHrh = variantHrh[1:]

			variantHrh = aEPOCROOT.Append(variantHrh)

			variantCfgDetails['VARIANT_HRH'] = variantHrh

		else:

			lineContent = line.split()

			if len(lineContent) == 1:

				variantCfgDetails[lineContent.pop(0)] = 1

			else:

				variantCfgDetails[lineContent.pop(0)] = lineContent

	variantCfgFile.close()

	if not variantCfgDetails.has_key('VARIANT_HRH'):

		raise MetaDataError("No variant file specified in "+str(aVariantCfgFile))

	if not variantHrh.isFile():

		raise MetaDataError("Variant file "+str(variantHrh)+" does not exist")

	return variantCfgDetails

def getOsVerFromKifXml(aPathToKifXml):

	"""Obtain the OS version from the kif.xml file located at $EPOCROOT/epoc32/data/kif.xml.

	If successful, the function returns a string such as "v95" to indicate 9.5; None is

	returned if for any reason the function cannot determine the OS version."""

	releaseTagName = "ki:release"

	osVersion = None

	import xml.dom.minidom

	try:

		# Parsed document object

		kifDom = xml.dom.minidom.parse(str(aPathToKifXml))

		# elements - the elements whose names are releaseTagName

		elements = kifDom.getElementsByTagName(releaseTagName)

		# There should be exactly one of the elements whose name is releaseTagName

		# If more than one, osVersion is left as None, since the version should be

		# unique to the kif.xml file

		if len(elements) == 1:

			osVersionTemp = elements[0].getAttribute("version")

			osVersion = "v" + osVersionTemp.replace(".", "")

		kifDom.unlink() # Clean up

	except:

		# There's no documentation on which exceptions are raised by these functions.

		# We catch everything and assume any exception means there was a failure to

		# determine OS version. None is returned, and the code will fall back

		# to looking at the buildinfo.txt file.

		pass

	return osVersion

def getOsVerFromBuildInfoTxt(aPathToBuildInfoTxt):

	"""Obtain the OS version from the buildinfo.txt file located at $EPOCROOT/epoc32/data/buildinfo.txt.

	If successful, the function returns a string such as "v95" to indicate 9.5; None is

	returned if for any reason the function cannot determine the OS version.

	The file $EPOCROOT/epoc32/data/buildinfo.txt is presumed to exist. The client code should

	handle existance/non-existance."""

	pathToBuildInfoTxt = str(aPathToBuildInfoTxt) # String form version of path to buildinfo.txt

	# Open the file for reading; throw an exception if it could not be read - note that

	# it should exist at this point.

	try:

		buildInfoTxt = open(pathToBuildInfoTxt)

	except IOError, (number, message):

		raise MetaDataError("Could not read buildinfo.txt file at" + pathToBuildInfoTxt + ": (" + message + ")")

	# Example buildinfo.txt contents:

	#

	# DeviceFamily               100

	# DeviceFamilyRev            0x900

	# ManufacturerSoftwareBuild  M08765_Symbian_OS_v9.5

	#

	# Regexp to match the line containing the OS version

	# Need to match things like M08765_Symbian_OS_v9.5 and M08765_Symbian_OS_vFuture

	# So for the version, match everything except whitespace after v. Whitespace

	# signifies the end of the regexp.

	osVersionMatcher = re.compile('.*_Symbian_OS_v([^\s]*)', re.I)

	osVersion = None

	# Search for a regexp match over all the times in the file

	# Note: if two or more lines match the search pattern then

	# the latest match will overwrite the osVersion string.

	for line in buildInfoTxt:

		matchResult = osVersionMatcher.match(line)

		if matchResult:

			result = matchResult.groups()

			osVersion = "v" +  str(reduce(lambda x, y: x + y, result))

			osVersion = osVersion.replace(".", "")

	buildInfoTxt.close() # Clean-up

	return osVersion

def getBuildableBldInfBuildPlatforms(aBldInfBuildPlatforms,

									aDefaultOSBuildPlatforms,

									aBaseDefaultOSBuildPlatforms,

									aBaseUserDefaultOSBuildPlatforms):

	"""Obtain a set of build platform names supported by a bld.inf file

	Build platform deduction is based on both the contents of the PRJ_PLATFORMS section of

	a bld.inf file together with a hard-coded set of default build platforms supported by

	the build system itself."""

	expandedBldInfBuildPlatforms = []

	removePlatforms = set()

	for bldInfBuildPlatform in aBldInfBuildPlatforms:

		if bldInfBuildPlatform.upper() == "DEFAULT":

			expandedBldInfBuildPlatforms.extend(aDefaultOSBuildPlatforms.split())

		elif bldInfBuildPlatform.upper() == "BASEDEFAULT":

			expandedBldInfBuildPlatforms.extend(aBaseDefaultOSBuildPlatforms.split())

		elif bldInfBuildPlatform.upper() == "BASEUSERDEFAULT":

			expandedBldInfBuildPlatforms.extend(aBaseUserDefaultOSBuildPlatforms.split())

		elif bldInfBuildPlatform.startswith("-"):

			removePlatforms.add(bldInfBuildPlatform.lstrip("-").upper())

		else:

			expandedBldInfBuildPlatforms.append(bldInfBuildPlatform.upper())

	if len(expandedBldInfBuildPlatforms) == 0:

		expandedBldInfBuildPlatforms.extend(aDefaultOSBuildPlatforms.split())

	# make a set of platforms that can be built

	buildableBldInfBuildPlatforms = set(expandedBldInfBuildPlatforms)

	# Add platforms that are buildable by virtue of the presence of another

	for piggyBackedPlatform in PiggyBackedBuildPlatforms:

		if piggyBackedPlatform in buildableBldInfBuildPlatforms:

			buildableBldInfBuildPlatforms.update(PiggyBackedBuildPlatforms.get(piggyBackedPlatform))

	# Remove platforms that were negated

	buildableBldInfBuildPlatforms -= removePlatforms

	return buildableBldInfBuildPlatforms

def getPreProcessorCommentDetail (aPreProcessorComment):

	"""Takes a preprocessor comment and returns an array containing the filename and linenumber detail."""

	commentDetail = []

	commentMatch = re.search('# (?P<LINENUMBER>\d+) "(?P<FILENAME>.*)"', aPreProcessorComment)

	if commentMatch:

		filename = commentMatch.group('FILENAME')

		filename = os.path.abspath(filename)

		filename = re.sub(r'\\\\', r'\\', filename)

		filename = re.sub(r'//', r'/', filename)

		filename = generic_path.Path(filename)

		linenumber = int (commentMatch.group('LINENUMBER'))

		commentDetail.append(filename)

		commentDetail.append(linenumber)

	return commentDetail

# Classes

class MetaDataError(Exception):

	"""Fatal error wrapper, to be thrown directly back to whatever is calling."""

	def __init__(self, aText):

		self.Text = aText

	def __str__(self):

		return repr(self.Text)

class PreProcessedLine(str):

	"""Custom string class that accepts filename and line number information from

	a preprocessed context."""

	def __new__(cls, value, *args, **keywargs):

		return str.__new__(cls, value)

	def __init__(self, value, aFilename, aLineNumber):

		self.filename = aFilename

		self.lineNumber = aLineNumber

	def getFilename (self):

		return self.filename

	def getLineNumber (self):

		return self.lineNumber

class PreProcessor(raptor_utilities.ExternalTool):

	"""Preprocessor wrapper suitable for Symbian metadata file processing."""

	def __init__(self, aPreProcessor,

				 aStaticOptions,

				 aIncludeOption,

				 aMacroOption,

				 aPreIncludeOption,

				 aRaptor):

		raptor_utilities.ExternalTool.__init__(self, aPreProcessor)

		self.__StaticOptions = aStaticOptions

		self.__IncludeOption = aIncludeOption

		self.__MacroOption = aMacroOption

		self.__PreIncludeOption = aPreIncludeOption

		self.filename = ""

		self.__Macros = []

		self.__IncludePaths = []

		self.__PreIncludeFile = ""

		self.raptor = aRaptor

	def call(self, aArgs, sourcefilename):

		""" Override call so that we can do our own error handling."""

		tool = self._ExternalTool__Tool

		try:

			commandline = tool + " " + aArgs + " " + str(sourcefilename)

			# the actual call differs between Windows and Unix

			if raptor_utilities.getOSFileSystem() == "unix":

				p = subprocess.Popen(commandline, \

									 shell=True, bufsize=65535, \

									 stdin=subprocess.PIPE, \

									 stdout=subprocess.PIPE, \

									 stderr=subprocess.PIPE, \

									 close_fds=True)

			else:

				p = subprocess.Popen(commandline, \

									 bufsize=65535, \

									 stdin=subprocess.PIPE, \

									 stdout=subprocess.PIPE, \

									 stderr=subprocess.PIPE, \

									 universal_newlines=True)

			# run the command and wait for all the output

			(self._ExternalTool__Output, errors) = p.communicate()

			if self.raptor.debugOutput:

				self.raptor.Debug("Preprocessing Start %s", str(sourcefilename))

				self.raptor.Debug("Output:\n%s", self._ExternalTool__Output)

				self.raptor.Debug("Errors:\n%s", errors)

				self.raptor.Debug("Preprocessing End %s", str(sourcefilename))

			incRE = re.compile("In file included from")

			fromRE = re.compile(r"\s+from")

			warningRE = re.compile("warning:|pasting.+token|from.+:")

			remarkRE = re.compile("no newline at end of file|does not give a valid preprocessing token")

			actualErr = False

			if errors != "":

				for error in errors.splitlines():

					if incRE.search(error) or fromRE.search(error):

						continue

					if not remarkRE.search(error):

						if warningRE.search(error):

							self.raptor.Warn("%s: %s", tool, error)

						else:

							self.raptor.Error("%s: %s", tool, error)

							actualErr = True

			if actualErr:

				raise MetaDataError("Errors in %s" % str(sourcefilename))

		except Exception,e:

			raise MetaDataError("Preprocessor exception: %s" % str(e))

		return 0	# all OK

	def setMacros(self, aMacros):

		self.__Macros = aMacros

	def addMacro(self, aMacro):

		self.__Macros.append(aMacro)

	def addMacros(self, aMacros):

		self.__Macros.extend(aMacros)

	def getMacros(self):

		return self.__Macros

	def addIncludePath(self, aIncludePath):

		p = str(aIncludePath)

		if p == "":

			self.raptor.Warn("attempt to set an empty preprocessor include path for %s" % str(self.filename))

		else:

			self.__IncludePaths.append(p)

	def addIncludePaths(self, aIncludePaths):

		for path in aIncludePaths:

			self.addIncludePath(path)

	def setIncludePaths(self, aIncludePaths):

		self.__IncludePaths = []

		self.addIncludePaths(aIncludePaths)

	def setPreIncludeFile(self, aPreIncludeFile):

		self.__PreIncludeFile = aPreIncludeFile

	def preprocess(self):

		preProcessorCall = self.__constructPreProcessorCall()

		returnValue = self.call(preProcessorCall, self.filename)

		return self.getOutput()

	def __constructPreProcessorCall(self):

		call = self.__StaticOptions

		if self.__PreIncludeFile:

			call += " " + self.__PreIncludeOption

			call += " " + str(self.__PreIncludeFile)

		for macro in self.__Macros:

			call += " " + self.__MacroOption + macro

		for includePath in self.__IncludePaths:

			call += " " + self.__IncludeOption

			call += " " + str(includePath)

		return call

class MetaDataFile(object):

	"""A generic representation of a Symbian metadata file

	Symbian metadata files are subject to preprocessing, primarily with macros based

	on the selected build platform.  This class provides a generic means of wrapping

	up the preprocessing of such files."""

	def __init__(self, aFilename, gnucpp, aRootLocation=None, log=None):

		"""

		@param aFilename	An MMP, bld.inf or other preprocessable build spec file

		@param aDefaultPlatform  Default preprocessed version of this file

		@param aCPP 		location of GNU CPP

		@param log 		A class with Debug(<string>), Info(<string>) and Error(<string>) methods

		"""

		self.filename = aFilename

		self.__RootLocation = aRootLocation

		# Dictionary with key of build platform and a text string of processed output as values

		self.__PreProcessedContent = {}

		self.log = log

		self.__gnucpp = gnucpp

		if gnucpp is None:

			raise ValueError('gnucpp must be set')

	def depspath(self, platform):

	   """ Where does dependency information go relative to platform's SBS_BUILD_DIR?

	       Subclasses should redefine this

	   """

	   return str(platform['SBS_BUILD_DIR']) + "/" + str(self.__RootLocation) + "." + platform['key_md5'] + ".d"

	def getContent(self, aBuildPlatform):

		key = aBuildPlatform['key']

		config_macros = []

		adepfilename = self.depspath(aBuildPlatform)

		generateDepsOptions = ""

		if adepfilename:

			if raptor_utilities.getOSPlatform().startswith("win"):

				metatarget = "$(PARSETARGET)"

			else:

				metatarget = "'$(PARSETARGET)'"

			generateDepsOptions = "-MD -MF%s -MT%s" % (adepfilename, metatarget)

			aBuildPlatform['METADEPS'].append((adepfilename, metatarget))

			try:

				os.makedirs(os.path.dirname(adepfilename))

			except Exception, e:

				self.log.Debug("Couldn't make bldinf outputpath for dependency generation")

		config_macros = (aBuildPlatform['PLATMACROS']).split()

		if not key in self.__PreProcessedContent:

			preProcessor = PreProcessor(self.__gnucpp, '-undef -nostdinc ' + generateDepsOptions + ' ',

										'-I', '-D', '-include', self.log)

			preProcessor.filename = self.filename

			# always have the current directory on the include path

			preProcessor.addIncludePath('.')

			# the SYSTEMINCLUDE directories defined in the build config

			# should be on the include path. This is added mainly to support

			# Feature Variation as SYSTEMINCLUDE is usually empty at this point.

			systemIncludes = aBuildPlatform['SYSTEMINCLUDE']

			if systemIncludes:

				preProcessor.addIncludePaths(systemIncludes.split())

			preInclude = aBuildPlatform['VARIANT_HRH']

			# for non-Feature Variant builds, the directory containing the HRH should

			# be on the include path

			if not aBuildPlatform['ISFEATUREVARIANT']:

				preProcessor.addIncludePath(preInclude.Dir())

			# and EPOCROOT/epoc32/include

			preProcessor.addIncludePath(aBuildPlatform['EPOCROOT'].Append('epoc32/include'))

			# and the directory containing the bld.inf file

			if self.__RootLocation is not None and str(self.__RootLocation) != "":

				preProcessor.addIncludePath(self.__RootLocation)

			# and the directory containing the file we are processing

			preProcessor.addIncludePath(self.filename.Dir())

			# there is always a pre-include file

			preProcessor.setPreIncludeFile(preInclude)

			macros = ["SBSV2"]

			if config_macros:

				macros.extend(config_macros)

			if macros:

				for macro in macros:

					preProcessor.addMacro(macro + "=_____" +macro)

			# extra "raw" macros that do not need protecting

			preProcessor.addMacro("__GNUC__=3")

			preProcessorOutput = preProcessor.preprocess()

			# Resurrect preprocessing replacements

			pattern = r'([\\|/]| |) ?_____(('+macros[0]+')'

			for macro in macros[1:]:

				pattern += r'|('+macro+r')'

			pattern += r'\s*)'

			# Work on all Macros in one substitution.

			text = re.sub(pattern, r"\1\2", preProcessorOutput)

			text = re.sub(r"\n[\t ]*", r"\n", text)

			self.__PreProcessedContent[key] = text

		return self.__PreProcessedContent[key]

class MMPFile(MetaDataFile):

	"""A generic representation of a Symbian metadata file

	Symbian metadata files are subject to preprocessing, primarily with macros based

	on the selected build platform.  This class provides a generic means of wrapping

	up the preprocessing of such files."""

	def __init__(self, aFilename, gnucpp, bldinf, log=None):

		"""

		@param aFilename	An MMP, bld.inf or other preprocessable build spec file

		@param gnucpp 		location of GNU CPP

		@param bldinf   	the bldinf file that this mmp comes from

		@param log 			A class with Debug(<string>), Info(<string>) and Error(<string>) methods

		"""

		super(MMPFile, self).__init__(aFilename, gnucpp, str(bldinf.filename.Dir()), log)

		self.__bldinf = bldinf

		self.__gnucpp = gnucpp