#
# Copyright (c) 2007-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: 
# 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 xml.sax.saxutils import escape
from mmpparser import *

import time
import generic_path


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

PlatformDefaultDefFileDir = {'WINSCW':'bwins',
				  'ARMV5' :'eabi',
				  'ARMV5SMP' :'eabi',
				  'GCCXML':'eabi',
				  'ARMV6':'eabi',
				  'ARMV7' : 'eabi',
				  'ARMV7SMP' : 'eabi',
				  'X86' : ['bx86gcc', '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


def getSpecName(aFileRoot, fullPath=False):
	"""Returns a build spec name: this is the file root (full path
	or simple file name) made safe for use as a file name."""

	if fullPath:
		specName = str(aFileRoot).replace("/","_")
		specName = specName.replace(":","")
	else:
		specName = aFileRoot.File()

	return specName.lower()


# 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
		commandline = tool + " " + aArgs + " " + str(sourcefilename)
		
		self.raptor.Debug("Preprocessing command line %s", str(commandline))
			
		try:
			# 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()

			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' : in command : '%s'" % (str(e), commandline))

		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, depfiles, 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 depfiles     	list to add dependency file tuples to
		@param aRootLocation    where the file is 
		@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.depfiles = depfiles

		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)
			self.depfiles.append((adepfilename, metatarget))
			try:
				os.makedirs(os.path.dirname(adepfilename))
			except Exception, e:
				self.log.Debug("Couldn't make bldinf outputpath for dependency generation")

		if not key in self.__PreProcessedContent:

			preProcessor = PreProcessor(self.__gnucpp, '-undef -nostdinc ' + generateDepsOptions + ' ',
										'-I', '-D', '-include', self.log)
			preProcessor.filename = self.filename

			# Set the preprocessor include paths
			self.setPreProcessorIncludePaths(preProcessor, aBuildPlatform)

			# there is always a pre-include file
			preInclude = aBuildPlatform['VARIANT_HRH']
			preProcessor.setPreIncludeFile(preInclude)

			# Set the preprocessor macros
			self.setPreProcessorMacros(preProcessor, aBuildPlatform)

			preProcessorOutput = preProcessor.preprocess()

			# Resurrect preprocessing replacements
			pattern = r'([\\|/]| |) ?_____(('+self.macros[0]+')'
			for macro in self.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]
	
	def setPreProcessorMacros(self, aPreprocessor, aBuildPlatform):
		""" Apply the macros for aBuildPlatform to a preprocessor object. """
		preprocessormacros = self.preparePreProcessorMacros(aBuildPlatform)
		for macro in preprocessormacros:
			aPreprocessor.addMacro(macro)
			
	def preparePreProcessorMacros(self, aBuildPlatform):
		""" Prepare a list of macros (e.g. for use by the preprocessor) """
		prepared_macros = []
		config_macros = (aBuildPlatform['PLATMACROS']).split()
		macros = ["SBSV2"]

		if config_macros:
			macros.extend(config_macros)

		if macros:
			for macro in macros:
				prepared_macros.append(macro + "=_____" +macro)
		
		self.macros = macros # For later use
		
		# extra "raw" macros that do not need protecting
		prepared_macros.append("__GNUC__=3")
		
		return prepared_macros
		
	def setPreProcessorIncludePaths(self, aPreprocessor, aBuildPlatform):
		""" setPreProcessorIncludePaths: set the preprocessor include paths """
		ppip = self.preparePreProcessorIncludePaths(aBuildPlatform)
		aPreprocessor.addIncludePaths(ppip)
		
	def preparePreProcessorIncludePaths(self, aBuildPlatform):
		""" Prepare a list of the include paths for use by the preprocessor. """
		paths = []
		
		# always have the current directory on the include path
		paths.append('.')

		# 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:
			paths.extend(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']:
			paths.append(preInclude.Dir())

		# and EPOCROOT/epoc32/include
		paths.append(aBuildPlatform['EPOCROOT'].Append('epoc32/include'))

		# and the directory containing the bld.inf file
		if self.__RootLocation is not None and str(self.__RootLocation) != "":
			paths.append(self.__RootLocation)

		# and the directory containing the file we are processing.
		# This won't always be applicable - if the client is a front-end query for preprocessing
		# include paths then there's no bld.inf path to take into account
		if self.filename.Dir().Exists():
			paths.append(self.filename.Dir())
		
		return paths

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, depfiles, log=None):
		"""
		@param aFilename	An MMP, bld.inf or other preprocessable build spec file
		@param gnucpp 		location of GNU CPP
		@param bldinf		the bld.inf file this mmp was specified in
		@param depfiles         list to fill with mmp dependency files
		@param log 		A class with Debug(<string>), Info(<string>) and Error(<string>) methods
		"""
		super(MMPFile, self).__init__(aFilename, gnucpp, depfiles, str(bldinf.filename.Dir()),  log)
		self.__bldinf = bldinf
		self.depfiles = depfiles

		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 self.__bldinf.outputpath(platform) + "/" + self.filename.File() + '.' + platform['key_md5'] + ".d"

class Export(object):
	"""Single processed PRJ_EXPORTS or PRJ_TESTEXPORTS entry from a bld.inf file"""

	def getPossiblyQuotedStrings(cls,spec):
		""" 	Split a string based on whitespace
			but keep double quoted substrings together.
		"""
		inquotes=False
		intokengap=False
		sourcedest=[]
		word = 0
		for c in spec:
			if c == '"':
				if inquotes:
					inquotes = False
					word += 1
					intokengap = True
				else:
					inquotes = True
					intokengap = False
				pass
			elif c == ' ' or c == '\t':
				if inquotes:
					if len(sourcedest) == word:
						sourcedest.append(c)
					else:
						sourcedest[word] += c
				else:
					if intokengap:
						# gobble unquoted spaces
						pass
					else:
						word += 1
						intokengap=True
				pass
			else:
				intokengap = False
				if len(sourcedest) == word:
					sourcedest.append(c)
				else:
					sourcedest[word] += c

		return sourcedest

	getPossiblyQuotedStrings = classmethod(getPossiblyQuotedStrings)


	def __init__(self, aBldInfFile, aExportsLine, aType):
		"""
		Rules from the OS library for convenience:

		For PRJ_TESTEXPORTS
		source_file_1 [destination_file]
		source_file_n [destination_file]
		If the source file is listed with a relative path, the path will
	 	  be considered relative to the directory containing the bld.inf file.
		If a destination file is not specified, the source file will be copied
		  to the directory containing the bld.inf file.
		If a relative path is specified with the destination file, the path
		  will be considered relative to directory containing the bld.inf file.

		For PRJ_EXPORTS
		source_file_1 [destination_file]
		source_file_n [destination_file]
		:zip zip_file [destination_path]

		Note that:
		If a source file is listed with a relative path, the path will be
		considered relative to the directory containing the bld.inf file.

		If a destination file is not specified, the source file will be copied
		to epoc32\include\.

		If a destination file is specified with the relative path, the path will
		be considered relative to directory epoc32\include\.

		If a destination begins with a drive letter, then the file is copied to
		epoc32\data\<drive_letter>\<path>. For example,

			mydata.dat e:\appdata\mydata.dat
			copies mydata.dat to epoc32\data\e\appdata\mydata.dat.
			You can use any driveletter between A and Z.

		A line can start with the preface :zip. This instructs the build tools
		to unzip the specified zip file to the specified destination path. If a
		destination path is not specified, the source file will be unzipped in
		the root directory.


		"""

		# Work out what action is required - unzip or copy?
		action = "copy"
		typematch = re.match(r'^\s*(?P<type>:zip\s+)?(?P<spec>[^\s].*[^\s])\s*$',aExportsLine, re.I)

		spec = typematch.group('spec')
		if spec == None:
			raise ValueError('must specify at least a source file for an export')

		if typematch.group('type') is not None:
			action = "unzip"

		# Split the spec into source and destination but take care
		# to allow filenames with quoted strings.
		exportEntries = Export.getPossiblyQuotedStrings(spec)

		# Get the source path as specified by the bld.inf
		source_spec = exportEntries.pop(0).replace(' ','%20')

		# Resolve the source file
		sourcepath = generic_path.Path(raptor_utilities.resolveSymbianPath(str(aBldInfFile), source_spec))

		# Find it if the case of the filename is wrong:
		# Carry on even if we don't find it
		foundfile = sourcepath.FindCaseless()
		if foundfile != None:
			source = str(foundfile).replace(' ','%20')
		else:
			source = str(sourcepath).replace(' ','%20')


		# Get the destination path as specified by the bld.inf
		if len(exportEntries) > 0:
			dest_spec = exportEntries.pop(0).replace(' ','%20')
		else:
			dest_spec = None
		# Destination list - list of destinations. For the WINSCW resource building stage,
		# files exported to the emulated drives and there are several locations, for example,
		# PRJ_[TEST]EXPORTS
		# 1234ABCD.SPD		z:/private/10009876/policy/1234ABCD.spd
		# needs to end up copied in
		# epoc32/data/z/private/10009876/policy/1234ABCD.spd *and* in
		# epoc32/release/winscw/udeb/z/private/10009876/policy/1234ABCD.spd *and* in
		# epoc32/release/winscw/urel/z/private/10009876/policy/1234ABCD.spd
		dest_list = []

		# Resolve the destination if one is specified
		if dest_spec:
			# check for troublesome characters
			if ':' in dest_spec and not re.search('^[a-z]:', dest_spec, re.I):
				raise ValueError("invalid filename " + dest_spec)

			dest_spec = dest_spec.replace(' ','%20')
			aSubType=""
			if action == "unzip":
				aSubType=":zip"
				dest_spec = dest_spec.rstrip("\\/")

			# Get the export destination(s) - note this can be a list of strings or just a string.
			dest_list = raptor_utilities.resolveSymbianPath(str(aBldInfFile), dest_spec, aType, aSubType)

			def process_dest(aDest):
				if dest_spec.endswith('/') or  dest_spec.endswith('\\'):
					m = generic_path.Path(source)
					aDest += '/'+m.File()
				return aDest

			if isinstance(dest_list, list):
				# Process each file in the list
				dest_list = map(process_dest, dest_list)
			else:
				# Process the single destination
				dest_list = process_dest(dest_list)

		else:
			# No destination was specified so we assume an appropriate one

			dest_filename=generic_path.Path(source).File()

			if aType == "PRJ_EXPORTS":
				if action == "copy":
					destination = '$(EPOCROOT)/epoc32/include/'+dest_filename
				elif action == "unzip":
					destination = '$(EPOCROOT)'
			elif aType == "PRJ_TESTEXPORTS":
				d = aBldInfFile.Dir()
				if action == "copy":
					destination = str(d.Append(dest_filename))
				elif action == "unzip":
					destination = "$(EPOCROOT)"
			else:
				raise ValueError("Export type should be 'PRJ_EXPORTS' or 'PRJ_TESTEXPORTS'. It was: "+str(aType))


		self.__Source = source
		if len(dest_list) > 0: # If the list has length > 0, this means there are several export destinations.
			self.__Destination = dest_list
		else: # Otherwise the list has length zero, so there is only a single export destination.
			self.__Destination = destination
		self.__Action = action

	def getSource(self):
		return self.__Source

	def getDestination(self):
		return self.__Destination # Note that this could be either a list, or a string, depending on the export destination

	def getAction(self):
		return self.__Action

class ExtensionmakefileEntry(object):
	def __init__(self, aGnuLine, aBldInfFile, tmp):

		self.__BldInfFile = aBldInfFile
		bldInfLocation = self.__BldInfFile.Dir()
		biloc = str(bldInfLocation)
		extInfLocation = tmp.filename.Dir()
		eiloc = str(extInfLocation)

		if eiloc is None or eiloc == "":
			eiloc="." # Someone building with a relative raptor path
		if biloc is None or biloc == "":
			biloc="." # Someone building with a relative raptor path

		self.__StandardVariables = {}
		# The source root directory is SRCROOT if set in the environment
		# Set TO_ROOT to SRCROOT in case SBS_BUILD_DIR is on a different drive
		if 'SRCROOT' in os.environ:
			self.__StandardVariables['TO_ROOT'] = str(generic_path.Path(os.environ['SRCROOT']))
		else:
			self.__StandardVariables['TO_ROOT'] = ""
		
		# Top-level bld.inf location
		self.__StandardVariables['TO_BLDINF'] = biloc
		self.__StandardVariables['EXTENSION_ROOT'] = eiloc

		# Get the directory and filename from the full path containing the extension makefile
		self.__FullPath = generic_path.Join(eiloc,aGnuLine)
		self.__FullPath = self.__FullPath.GetLocalString()
		self.__Filename = os.path.split(self.__FullPath)[1]
		self.__Directory = os.path.split(self.__FullPath)[0]

	def getMakefileName(self):
		return self.__Filename

	def getMakeDirectory(self):
		return self.__Directory

	def getStandardVariables(self):
		return self.__StandardVariables

class Extension(object):
	"""Single processed PRJ_EXTENSIONS or PRJ_TESTEXTENSIONS START EXTENSIONS...END block
	from a bld.inf file"""

	def __init__(self, aBldInfFile, aStartLine, aOptionLines, aBuildPlatform, aRaptor):
		self.__BldInfFile = aBldInfFile
		self.__Options = {}
		self.interface = ""
		self.__Raptor = aRaptor

		makefile = ""
		makefileMatch = re.search(r'^\s*START EXTENSION\s+(?P<MAKEFILE>\S+)\s*(?P<NAMETAG>\S*)$', aStartLine, re.I)

		self.__RawMakefile = ""

		if (makefileMatch):
			self.__RawMakefile = makefileMatch.group('MAKEFILE')
			self.nametag = makefileMatch.group('NAMETAG').lower()

			# Ensure all \'s are translated into /'s if required
			self.interface = self.__RawMakefile
			self.interface = self.interface.replace("\\", "/").replace("/", ".")

		# To support standalone testing, '$(' prefixed TEMs  are assumed to  start with
		# a makefile variable and hence be fully located in FLM operation
		if self.__RawMakefile.startswith("$("):
			self.__Makefile = self.__RawMakefile + ".mk"
		else:
			self.__Makefile = '$(MAKEFILE_TEMPLATES)/' + self.__RawMakefile + ".mk"

		for optionLine in aOptionLines:
			optionMatch = re.search(r'^\s*(OPTION\s+)?(?P<VARIABLE>\S+)\s+(?P<VALUE>\S+.*)$',optionLine, re.I)
			if optionMatch:
				self.__Options[optionMatch.group('VARIABLE').upper()] = optionMatch.group('VALUE')

		bldInfLocation = self.__BldInfFile.Dir()

		biloc = str(bldInfLocation)
		if biloc is None or biloc == "":
			biloc="." # Someone building with a relative raptor path

		extInfLocation = aStartLine.filename.Dir()

		eiloc = str(extInfLocation)
		if eiloc is None or eiloc == "":
			eiloc="." # Someone building with a relative raptor path

		self.__StandardVariables = {}
		# The source root directory is SRCROOT if set in the environment	
		# Set TO_ROOT to SRCROOT in case SBS_BUILD_DIR is on a different drive
		if 'SRCROOT' in os.environ:
			self.__StandardVariables['TO_ROOT'] = str(generic_path.Path(os.environ['SRCROOT']))
		else:
			self.__StandardVariables['TO_ROOT'] = ""
		# Top-level bld.inf location
		self.__StandardVariables['TO_BLDINF'] = biloc
		# Location of bld.inf file containing the current EXTENSION block
		self.__StandardVariables['EXTENSION_ROOT'] = eiloc

		# If the interface exists, this means it's not a Template Extension Makefile so don't look for a .meta file for it;
		# so do nothing if it's not a template extension makefile
		try:
			self.__Raptor.cache.FindNamedInterface(str(self.interface), aBuildPlatform['CACHEID'])
		except KeyError: # This means that this Raptor doesn't have the interface self.interface, so we are in a TEM
			# Read extension meta file and get default options from it.  The use of TEM meta file is compulsory if TEM is used
			metaFilename = "%s/epoc32/tools/makefile_templates/%s.meta" % (aBuildPlatform['EPOCROOT'], self.__RawMakefile)
			metaFile = None
			try:
				metaFile = open(metaFilename, "r")
			except IOError, e:
				self.__warn("Extension: %s - cannot open Meta file: %s" % (self.__RawMakefile, metaFilename))

			if metaFile:
				for line in metaFile.readlines():
					defaultOptionMatch = re.search(r'^OPTION\s+(?P<VARIABLE>\S+)\s+(?P<VALUE>\S+.*)$',line, re.I)
					if defaultOptionMatch and defaultOptionMatch.group('VARIABLE').upper() not in self.__Options.keys():
						self.__Options[defaultOptionMatch.group('VARIABLE').upper()] = defaultOptionMatch.group('VALUE')

				metaFile.close()

	def __warn(self, format, *extras):
		if (self.__Raptor):
			self.__Raptor.Warn(format, *extras)

	def getIdentifier(self):
		return re.sub (r'\\|\/|\$|\(|\)', '_', self.__RawMakefile)

	def getMakefile(self):
		return self.__Makefile

	def getOptions(self):
		return self.__Options

	def getStandardVariables(self):
		return self.__StandardVariables

class MMPFileEntry(object):
	def __init__(self, aFilename, aTestOption, aARMOption):
		self.filename = aFilename
		self.testoption = aTestOption
		if aARMOption:
			self.armoption = True
		else:
			self.armoption = False


class BldInfFile(MetaDataFile):
	"""Representation of a Symbian bld.inf file"""

	def __init__(self, aFilename, gnucpp, depfiles, log=None):
		MetaDataFile.__init__(self, aFilename, gnucpp, depfiles, None, log)
		self.__Raptor = log
		self.testManual = 0
		self.testAuto = 0
	# Generic

	def getBuildPlatforms(self, aBuildPlatform):
		platformList = []

		for platformLine in self.__getSection(aBuildPlatform, 'PRJ_PLATFORMS'):
			for platformEntry in platformLine.split():
				platformList.append(platformEntry)

		return platformList

	# Build Platform Specific
	def getMMPList(self, aBuildPlatform, aType="PRJ_MMPFILES"):
		mmpFileList=[]
		gnuList = []
		makefileList = []
		extFound = False
		m = None

		hashValue = {'mmpFileList': [] , 'gnuList': [], 'makefileList' : []}

		for mmpFileEntry in self.__getSection(aBuildPlatform, aType):

			actualBldInfRoot = mmpFileEntry.getFilename()
			n = re.match('\s*(?P<makefiletype>(GNUMAKEFILE|N?MAKEFILE))\s+(?P<extmakefile>[^ ]+)\s*(support|manual)?\s*(?P<invalid>\S+.*)?\s*$',mmpFileEntry,re.I)
			if n:

				if (n.groupdict()['invalid']):
					self.log.Error("%s (%d) : invalid .mmp file qualifier \"%s\"", mmpFileEntry.filename, mmpFileEntry.getLineNumber(), n.groupdict()['invalid'])
				if raptor_utilities.getOSFileSystem() == "unix":
					self.log.Warn("NMAKEFILE/GNUMAKEFILE/MAKEFILE keywords not supported on Linux")
				else:
					extmakefilearg = n.groupdict()['extmakefile']
					bldInfDir = actualBldInfRoot.Dir()
					extmakefilename = bldInfDir.Append(extmakefilearg)
					extmakefile = ExtensionmakefileEntry(extmakefilearg, self.filename, mmpFileEntry)

					if (n.groupdict()['makefiletype']).upper() == "GNUMAKEFILE":
						gnuList.append(extmakefile)
					else:
						makefileList.append(extmakefile)
			else:
				# Currently there is only one possible option - build as arm.
				# For TESTMMPFILES, the supported options are support, tidy, ignore, manual and build as arm
				if aType.upper()=="PRJ_TESTMMPFILES":
					if re.match('\s*(?P<name>[^ ]+)\s*(?P<baa>build_as_arm)?\s*(?P<support>support)?\s*(?P<ignore>ignore)?\s*(?P<tidy>tidy)?\s*(?P<manual>manual)?\s*(?P<invalid>\S+.*)?\s*$', mmpFileEntry, re.I):
						m = re.match('\s*(?P<name>[^ ]+)\s*(?P<baa>build_as_arm)?\s*(?P<support>support)?\s*(?P<ignore>ignore)?\s*(?P<tidy>tidy)?\s*(?P<manual>manual)?\s*(?P<invalid>\S+.*)?\s*$', mmpFileEntry, re.I)
				else:
					if re.match('\s*(?P<name>[^ ]+)\s*(?P<baa>build_as_arm)?\s*(?P<invalid>\S+.*)?\s*$', mmpFileEntry, re.I):
						m = re.match('\s*(?P<name>[^ ]+)\s*(?P<baa>build_as_arm)?\s*(?P<invalid>\S+.*)?\s*$', mmpFileEntry, re.I)

			if m:
				if (m.groupdict()['invalid']):
					self.log.Error("%s (%d) : invalid .mmp file qualifier \"%s\"", mmpFileEntry.filename, mmpFileEntry.getLineNumber(), m.groupdict()['invalid'])

				mmpFileName = m.groupdict()['name']
				testmmpoption = "auto" # Setup tests to be automatic by default
				tokens = m.groupdict()
				for key,item in tokens.iteritems():
					if key=="manual" and item=="manual":
						testmmpoption = "manual"
					elif key=="support" and item=="support":
						testmmpoption = "support"
					elif key=="ignore" and item=="ignore":
						testmmpoption = "ignore"

				buildasarm = False
				if  m.groupdict()['baa']:
					if m.groupdict()['baa'].lower() == 'build_as_arm':
						buildasarm = True

				if not mmpFileName.lower().endswith('.mmp'):
					mmpFileName += '.mmp'
				bldInfDir = actualBldInfRoot.Dir()
				try:
					mmpFileName = bldInfDir.Append(mmpFileName)
					mmpfe = MMPFileEntry(mmpFileName, testmmpoption, buildasarm)
					mmpFileList.append(mmpfe)
				except ValueError, e:
					self.log.Error("invalid .mmp file name: %s" % str(e))

				m = None


		hashValue['mmpFileList'] = mmpFileList
		hashValue['gnuList'] = gnuList
		hashValue['makefileList'] = makefileList

		return hashValue

	# Return a list of gnumakefiles used in the bld.inf
	def getExtensionmakefileList(self, aBuildPlatform, aType="PRJ_MMPFILES",aString = ""):
		extMakefileList=[]
		m = None
		for extmakeFileEntry in self.__getSection(aBuildPlatform, aType):

			actualBldInfRoot = extmakeFileEntry.filename
			if aType.upper()=="PRJ_TESTMMPFILES":
				m = re.match('\s*GNUMAKEFILE\s+(?P<extmakefile>[^ ]+)\s*(?P<support>support)?\s*(?P<ignore>ignore)?\s*(?P<tidy>tidy)?\s*(?P<manual>manual)?\s*(?P<invalid>\S+.*)?\s*$',extmakeFileEntry,re.I)
			else:
				if aString == "gnumakefile":
					m = re.match('\s*GNUMAKEFILE\s+(?P<extmakefile>[^ ]+)\s*(?P<invalid>\S+.*)?\s*$',extmakeFileEntry,re.I)
				elif aString == "nmakefile":
					m = re.match('\s*NMAKEFILE\s+(?P<extmakefile>[^ ]+)\s*(?P<invalid>\S+.*)?\s*$',extmakeFileEntry,re.I)
				elif aString == "makefile":
					m = re.match('\s*MAKEFILE\s+(?P<extmakefile>[^ ]+)\s*(?P<invalid>\S+.*)?\s*$',extmakeFileEntry,re.I)
			if m:
				if (m.groupdict()['invalid']):
					self.log.Error("%s (%d) : invalid extension makefile qualifier \"%s\"", extmakeFileEntry.filename, extmakeFileEntry.getLineNumber(), m.groupdict()['invalid'])

				extmakefilearg = m.groupdict()['extmakefile']
				bldInfDir = actualBldInfRoot.Dir()
				extmakefilename = bldInfDir.Append(extmakefilearg)
				extmakefile = ExtensionmakefileEntry(extmakefilearg, self.filename, extmakeFileEntry)
				extMakefileList.append(extmakefile)
				m = None

		return extMakefileList

	def getTestExtensionmakefileList(self,aBuildPlatform,aString=""):
		return self.getExtensionmakefileList(aBuildPlatform,"PRJ_TESTMMPFILES",aString)

	def getTestMMPList(self, aBuildPlatform):
		return self.getMMPList(aBuildPlatform, "PRJ_TESTMMPFILES")

	def getRomTestType(self, aBuildPlatform):
		testMMPList = self.getTestMMPList(aBuildPlatform)
		for testMMPFileEntry in testMMPList['mmpFileList']:
			if aBuildPlatform["TESTCODE"]:
				# Calculate test type (manual or auto)
				if testMMPFileEntry.testoption == "manual":
					self.testManual += 1
				if not (testMMPFileEntry.testoption == "support" or testMMPFileEntry.testoption == "manual" or testMMPFileEntry.testoption == "ignore"):
					self.testAuto += 1
		if self.testManual and self.testAuto:
			return 'BOTH'
		elif self.testAuto:
			return 'AUTO'
		elif self.testManual:
			return 'MANUAL'
		else:
			return 'NONE'

	def getExports(self, aBuildPlatform, aType="PRJ_EXPORTS"):
		exportList = []

		for exportLine in self.__getSection(aBuildPlatform, aType):

			if not re.match(r'\S+', exportLine):
				continue

			try:
				exportList.append(Export(exportLine.getFilename(), exportLine, aType))
			except ValueError,e:
				self.log.Error(str(e))

		return exportList

	def getTestExports(self, aBuildPlatform):
		return self.getExports(aBuildPlatform, "PRJ_TESTEXPORTS")

	def getExtensions(self, aBuildPlatform, aType="PRJ_EXTENSIONS"):
		extensionObjects = []
		start = ""
		options = []

		for extensionLine in self.__getSection(aBuildPlatform, aType):
			if (re.search(r'^\s*START ',extensionLine, re.I)):
				start = extensionLine
			elif re.search(r'^\s*END\s*$',extensionLine, re.I):
				if start == "":
					self.log.Error("unmatched END statement in %s section", aType, bldinf=str(self.filename))
				else:
					extensionObjects.append(Extension(self.filename, start, options, aBuildPlatform, self.__Raptor))
					start = ""
					options = []
			elif re.search(r'^\s*$',extensionLine, re.I):
				continue
			elif start:
				options.append(extensionLine)

		return extensionObjects

	def getTestExtensions(self, aBuildPlatform):
		return self.getExtensions(aBuildPlatform, "PRJ_TESTEXTENSIONS")

	def __getSection(self, aBuildPlatform, aSection):

		activeSection = False
		sectionContent = []
		lineContent = re.split(r'\n', self.getContent(aBuildPlatform));

		currentBldInfFile = self.filename
		currentLineNumber = 0

		for line in lineContent:
			if line.startswith("#"):
				commentDetail = getPreProcessorCommentDetail(line)
				currentBldInfFile = commentDetail[0]
				currentLineNumber = commentDetail[1]-1
				continue

			currentLineNumber += 1

			if not re.match(r'.*\S+', line):
				continue
			elif re.match(r'\s*' + aSection + r'\s*$', line, re.I):
				activeSection = True
			elif re.match(r'\s*PRJ_\w+\s*$', line, re.I):
				activeSection = False
			elif activeSection:
				sectionContent.append(PreProcessedLine(line, currentBldInfFile, currentLineNumber))

		return sectionContent

	@staticmethod
	def outputPathFragment(bldinfpath):
		"""Return a relative path that uniquely identifies this bldinf file
		   whilst being short so that it can be appended to epoc32/build.
		   The  build product of a particular bld.inf may be placed in here.
		   This affects its TEMs and its MMPs"""

		absroot_str = os.path.abspath(str(bldinfpath)).lower().replace("\\","/")

		uniqueid = hashlib.md5()
		uniqueid.update(absroot_str)

		specnamecomponents = (re.sub("^[A-Za-z]:", "", absroot_str)).split('/') # split, removing any drive identifier (if present)

		pathlist=[]
		while len(specnamecomponents) > 0:
			top = specnamecomponents.pop()
			if top.endswith('.inf'):
				continue
			elif top == 'group':
				continue
			else:
				pathlist = [top]
				break

		pathlist.append("c_"+uniqueid.hexdigest()[:16])
		return "/".join(pathlist)

	def outputpath(self, platform):
		""" The full path where product from this bldinf is created."""
		return str(platform['SBS_BUILD_DIR']) + "/" + BldInfFile.outputPathFragment(self.filename)

	def depspath(self, platform):
	   """ Where does dependency information go relative to platform's SBS_BUILD_DIR?
	       Subclasses should redefine this
	   """
	   return self.outputpath(platform) + "/bldinf." + platform['key_md5'] + ".d"



class MMPRaptorBackend(MMPBackend):
	"""A parser "backend" for the MMP language

	This is used to map recognised MMP syntax onto a buildspec """

	# Support priorities, with case-fixed mappings for use
	epoc32priorities = {
		'low':'Low',
		'background':'Background',
		'foreground':'Foreground',
		'high':'High',
		'windowserver':'WindowServer',
		'fileserver':'FileServer',
		'realtimeserver':'RealTimeServer',
		'supervisor':'SuperVisor'
		}

	# Known capability flags with associated bitwise operations
	supportedCapabilities = {
		'tcb':(1<<0),
		'commdd':(1<<1),
		'powermgmt':(1<<2),
		'multimediadd':(1<<3),
		'readdevicedata':(1<<4),
		'writedevicedata':(1<<5),
		'drm':(1<<6),
		'trustedui':(1<<7),
		'protserv':(1<<8),
		'diskadmin':(1<<9),
		'networkcontrol':(1<<10),
		'allfiles':(1<<11),
		'swevent':(1<<12),
		'networkservices':(1<<13),
		'localservices':(1<<14),
		'readuserdata':(1<<15),
		'writeuserdata':(1<<16),
		'location':(1<<17),
		'surroundingsdd':(1<<18),
		'userenvironment':(1<<19),
	# Old capability names have zero value
		'root':0,
		'mediadd':0,
		'readsystemdata':0,
		'writesystemdata':0,
		'sounddd':0,
		'uidd':0,
		'killanyprocess':0,
		'devman':0,
		'phonenetwork':0,
		'localnetwork':0
	  	}
	
	# Valid ARMFPU options
	armfpu_options = [
		'softvfp',
		'vfpv2',
		'softvfp+vfpv2'
		]

	library_re = re.compile(r"^(?P<name>[^{]+?)(?P<version>{(?P<major>[0-9]+)\.(?P<minor>[0-9]+)})?(\.(lib|dso))?$",re.I)


	def __init__(self, aRaptor, aMmpfilename, aBldInfFilename):
		super(MMPRaptorBackend,self).__init__()
		self.platformblock = None
		self.__Raptor = aRaptor
		self.__debug("-----+++++ %s " % aMmpfilename)
		self.BuildVariant = raptor_data.Variant(name = "mmp")
		self.ApplyVariants = []
		self.ResourceVariants = []
		self.BitmapVariants = []
		self.StringTableVariants = []
		self.__bldInfFilename = aBldInfFilename
		self.__targettype = "UNKNOWN"
		self.__currentMmpFile = aMmpfilename
		self.__defFileRoot = self.__currentMmpFile
		self.__currentLineNumber = 0
		self.__sourcepath = raptor_utilities.resolveSymbianPath(self.__currentMmpFile, "")
		self.__userinclude = ""
		self.__systeminclude = ""
		self.__bitmapSourcepath = self.__sourcepath
		self.__current_resource = ""
		self.__resourceFiles = []
		self.__pageConflict = []
		self.__debuggable = ""
		self.__compressionKeyword = ""
		self.sources = []
		self.capabilities = []
		self.documents = []

		self.__TARGET = ""
		self.__TARGETEXT = ""
		self.deffile = ""
		self.__LINKAS = ""
		self.nostrictdef = False
		self.featureVariant = False

		self.__currentResourceVariant = None
		self.__currentStringTableVariant = None
		self.__explicitversion = False
		self.__versionhex = ""

		# "ALL" capability calculated based on the total capabilities currently supported
		allCapabilities = 0
		for supportedCapability in MMPRaptorBackend.supportedCapabilities.keys():
			allCapabilities = allCapabilities | MMPRaptorBackend.supportedCapabilities[supportedCapability]
		MMPRaptorBackend.supportedCapabilities['all'] = allCapabilities

	# Permit unit-testing output without a Raptor context
	def __debug(self, format, *extras):
		if (self.__Raptor):
			self.__Raptor.Debug(format, *extras)

	def __warn(self, format, *extras):
		if (self.__Raptor):
			self.__Raptor.Warn(format, *extras)

	def doPreProcessorComment(self,s,loc,toks):
		commentDetail = getPreProcessorCommentDetail(toks[0])
		self.__currentMmpFile = commentDetail[0].GetLocalString()
		self.__currentLineNumber = commentDetail[1]
		self.__debug("Current file %s, line number %s\n"  % (self.__currentMmpFile,str(self.__currentLineNumber)))
		return "OK"

	def doBlankLine(self,s,loc,toks):
		self.__currentLineNumber += 1

	def doStartPlatform(self,s,loc,toks):
		self.__currentLineNumber += 1
		self.__debug( "Start Platform block "+toks[0])
		self.platformblock = toks[0]
		return "OK"

	def doEndPlatform(self,s,loc,toks):
		self.__currentLineNumber += 1
		self.__debug( "Finalise platform " + self.platformblock)
		return "OK"

	def doSetSwitch(self,s,loc,toks):
		self.__currentLineNumber += 1
		prefix=""
		varname = toks[0].upper()

		# A bright spark made the optionname the same as
		# the env variable. One will override the other if we pass this
		# on to make.  Add a prefix to prevent the clash.
		if varname=='ARMINC':
			prefix="SET_"
			self.__debug( "Set switch "+toks[0]+" ON")
			self.BuildVariant.AddOperation(raptor_data.Set(prefix+varname, "1"))

		elif varname=='NOSTRICTDEF':
			self.nostrictdef = True
			self.__debug( "Set switch "+toks[0]+" ON")
			self.BuildVariant.AddOperation(raptor_data.Set(prefix+varname, "1"))

		elif varname == 'PAGED':
			self.BuildVariant.AddOperation(raptor_data.Set(varname, "1"))
			self.__debug( "Set switch PAGE ON")
			# PAGED is equivalent to PAGEDCODE
			self.BuildVariant.AddOperation(raptor_data.Set("PAGEDCODE_OPTION", "paged"))
			self.__debug( "Set switch PAGEDCODE ON")
			self.__pageConflict.append("PAGEDCODE")

		elif varname == 'UNPAGED':
			self.BuildVariant.AddOperation(raptor_data.Set("PAGED", "0"))
			self.__debug( "Set switch PAGED OFF")
			# UNPAGED is equivalent to UNPAGEDCODE *and* UNPAGEDDATA
			self.BuildVariant.AddOperation(raptor_data.Set("PAGEDCODE_OPTION", "unpaged"))
			self.__debug( "Set switch PAGEDCODE OFF")
			self.BuildVariant.AddOperation(raptor_data.Set("PAGEDDATA_OPTION", "unpaged"))
			self.__debug( "Set data PAGEDDATA OFF")
			self.__pageConflict.append("UNPAGEDCODE")
			self.__pageConflict.append("UNPAGEDDATA")

		elif varname == 'PAGEDCODE':
			self.BuildVariant.AddOperation(raptor_data.Set("PAGEDCODE_OPTION", "paged"))
			self.__debug( "Set switch " + varname + " ON")
			self.__pageConflict.append(varname)

		elif varname == 'PAGEDDATA':
			self.BuildVariant.AddOperation(raptor_data.Set("PAGEDDATA_OPTION", "paged"))
			self.__debug( "Set switch " + varname + " ON")
			self.__pageConflict.append(varname)

		elif varname == 'UNPAGEDCODE':
			self.BuildVariant.AddOperation(raptor_data.Set("PAGEDCODE_OPTION", "unpaged"))
			self.__debug( "Set switch " + varname + " ON")
			self.__pageConflict.append(varname)
			
		elif varname == 'UNPAGEDDATA':
			self.BuildVariant.AddOperation(raptor_data.Set("PAGEDDATA_OPTION", "unpaged"))
			self.__debug( "Set switch " + varname + " ON")
			self.__pageConflict.append(varname)

		elif varname == 'NOLINKTIMECODEGENERATION':
			self.BuildVariant.AddOperation(raptor_data.Set("LTCG",""))
			self.__debug( "Set switch " + varname + " OFF")
			
		elif varname == 'NOMULTIFILECOMPILATION':
			self.BuildVariant.AddOperation(raptor_data.Set("MULTIFILE_ENABLED",""))
			self.__debug( "Set switch " + varname + " OFF")

		elif varname == 'DEBUGGABLE':
			if self.__debuggable != "udeb":
				self.__debuggable = "udeb urel"
			else:
				self.__Raptor.Warn("DEBUGGABLE keyword ignored as DEBUGGABLE_UDEBONLY is already specified")
		
		elif varname == 'DEBUGGABLE_UDEBONLY':
			if self.__debuggable != "":
				self.__Raptor.Warn("DEBUGGABLE keyword has no effect as DEBUGGABLE or DEBUGGABLE_UDEBONLY is already set")
			self.__debuggable = "udeb"
		
		elif varname == 'FEATUREVARIANT':
			self.BuildVariant.AddOperation(raptor_data.Set(varname,"1"))
			self.featureVariant = True
		
		elif varname in ['COMPRESSTARGET', 'NOCOMPRESSTARGET', 'INFLATECOMPRESSTARGET', 'BYTEPAIRCOMPRESSTARGET']:
			self.resolveCompressionKeyword(varname)
		
		else:
			self.__debug( "Set switch "+toks[0]+" ON")
			self.BuildVariant.AddOperation(raptor_data.Set(prefix+varname, "1"))

		return "OK"

	def doAssignment(self,s,loc,toks):
		self.__currentLineNumber += 1
		varname = toks[0].upper()
		if varname=='TARGET':
			(self.__TARGET, self.__TARGETEXT) = os.path.splitext(toks[1])
			self.__TARGETEXT = self.__TARGETEXT.lstrip('.')

			self.BuildVariant.AddOperation(raptor_data.Set("REQUESTEDTARGETEXT", self.__TARGETEXT.lower()))

			lowercase_TARGET = self.__TARGET.lower()
			self.__debug("Set "+toks[0]+" to " + lowercase_TARGET)
			self.__debug("Set REQUESTEDTARGETEXT to " + self.__TARGETEXT.lower())

			self.BuildVariant.AddOperation(raptor_data.Set("TARGET", self.__TARGET))
			self.BuildVariant.AddOperation(raptor_data.Set("TARGET_lower", lowercase_TARGET))
			if  lowercase_TARGET !=  self.__TARGET:
				self.__debug("TARGET is not lowercase: '%s' - might cause BC problems." % self.__TARGET)
		elif varname=='TARGETTYPE':
			self.__debug("Set "+toks[0]+" to " + str(toks[1]))
			self.__targettype=toks[1]
			if  self.__targettype.lower() == "none":
				self.BuildVariant.AddOperation(raptor_data.Set("TARGET", ""))
				self.BuildVariant.AddOperation(raptor_data.Set("TARGET_lower",""))
				self.BuildVariant.AddOperation(raptor_data.Set("REQUESTEDTARGETEXT", ""))
			self.BuildVariant.AddOperation(raptor_data.Set(varname,toks[1].lower()))

		elif varname=='TARGETPATH':
			value = toks[1].lower().replace('\\','/')
			self.__debug("Set "+varname+" to " + value)
			self.BuildVariant.AddOperation(raptor_data.Set(varname, value))

		elif varname=='OPTION' or varname=='LINKEROPTION':
			self.__debug("Set "+toks[1]+varname+" to " + str(toks[2]))
			self.BuildVariant.AddOperation(raptor_data.Append(varname+"_"+toks[1].upper()," ".join(toks[2])))

			# Warn about OPTION ARMASM
			if "armasm" in toks[1].lower():
				self.__Raptor.Warn(varname+" ARMASM has no effect (use OPTION ARMCC).")

		elif varname=='OPTION_REPLACE':
			# Warn about OPTION_REPLACE ARMASM
			if "armasm" in toks[1].lower():
				self.__Raptor.Warn("OPTION_REPLACE ARMASM has no effect (use OPTION_REPLACE ARMCC).")
			else:
				args = " ".join(toks[2])

				searchReplacePairs = self.resolveOptionReplace(args)

				for searchReplacePair in searchReplacePairs:
					self.__debug("Append %s to OPTION_REPLACE_%s", searchReplacePair, toks[1].upper())
					self.BuildVariant.AddOperation(raptor_data.Append(varname+"_"+toks[1].upper(),searchReplacePair))

		elif varname=='SYSTEMINCLUDE' or varname=='USERINCLUDE':
			for path in toks[1]:
				resolved = raptor_utilities.resolveSymbianPath(self.__currentMmpFile, path)
				self.BuildVariant.AddOperation(raptor_data.Append(varname,resolved))

				if varname=='SYSTEMINCLUDE':
					self.__systeminclude += ' ' + resolved
					self.__debug("  %s = %s",varname, self.__systeminclude)
				else:
					self.__userinclude += ' ' + resolved
					self.__debug("  %s = %s",varname, self.__userinclude)

				self.__debug("Appending %s to %s",resolved, varname)

			self.__systeminclude = self.__systeminclude.strip()
			self.__systeminclude = self.__systeminclude.rstrip('\/')
			self.__userinclude = self.__userinclude.strip()
			self.__userinclude = self.__userinclude.rstrip('\/')

		elif varname=='EXPORTLIBRARY':
			# Remove extension from the EXPORTLIBRARY name
			libName = toks[1].rsplit(".", 1)[0]
			self.__debug("Set "+varname+" to " + libName)
			self.BuildVariant.AddOperation(raptor_data.Set(varname,"".join(libName)))

		elif varname=='CAPABILITY':
			for cap in toks[1]:
				cap = cap.lower()
				self.__debug("Setting  "+toks[0]+": " + cap)
				if not cap.startswith("-"):
					if not cap.startswith("+"):
						cap = "+" + cap	
				self.capabilities.append(cap)
		elif varname=='DEFFILE':
			self.__defFileRoot = self.__currentMmpFile
			self.deffile = toks[1]
		elif varname=='LINKAS':
			self.__debug("Set "+toks[0]+"  OPTION to " + str(toks[1]))
			self.__LINKAS = toks[1]
			self.BuildVariant.AddOperation(raptor_data.Set(varname, toks[1]))
		elif varname=='SECUREID' or varname=='VENDORID':
			hexoutput = MMPRaptorBackend.canonicalUID(toks[1])
			self.__debug("Set "+toks[0]+"  OPTION to " + hexoutput)
			self.BuildVariant.AddOperation(raptor_data.Set(varname, hexoutput))
		elif varname=='VERSION':
			if toks[-1] == "EXPLICIT":
				self.__explicitversion = True
				self.BuildVariant.AddOperation(raptor_data.Set("EXPLICITVERSION", "1"))

			vm = re.match(r'^(\d+)(\.(\d+))?$', toks[1])
			if vm is not None:
				version = vm.groups()
				# the major version number
				major = int(version[0],10)

				# add in the minor number
				minor = 0
				if version[1] is not None:
					minor = int(version[2],10)
				else:
					self.__Raptor.Warn("VERSION (%s) missing '.minor' in %s, using '.0'" % (toks[1],self.__currentMmpFile))

				self.__versionhex = "%04x%04x" % (major, minor)
				self.BuildVariant.AddOperation(raptor_data.Set(varname, "%d.%d" %(major, minor)))
				self.BuildVariant.AddOperation(raptor_data.Set("VERSIONHEX", self.__versionhex))
				self.__debug("Set "+toks[0]+"  OPTION to " + toks[1])
				self.__debug("Set VERSIONHEX OPTION to " + self.__versionhex)

			else:
				self.__Raptor.Warn("Invalid version supplied to VERSION (%s), using default value" % toks[1])

		elif varname=='EPOCHEAPSIZE':
			# Standardise on sending hex numbers to the FLMS.

			if toks[1].lower().startswith('0x'):
				min = long(toks[1],16)
			else:
				min = long(toks[1],10)

			if toks[2].lower().startswith('0x'):
				max = long(toks[2],16)
			else:
				max = long(toks[2],10)

			self.BuildVariant.AddOperation(raptor_data.Set(varname+"MIN", "%x" % min))
			self.__debug("Set "+varname+"MIN  OPTION to '%x' (hex)" % min )
			self.BuildVariant.AddOperation(raptor_data.Set(varname+"MAX", "%x" % max))
			self.__debug("Set "+varname+"MAX  OPTION to '%x' (hex)" % max )

			# Some toolchains require decimal versions of the min/max values, converted to KB and
			# rounded up to the next 1KB boundary
			min_dec_kb = (int(min) + 1023) / 1024
			max_dec_kb = (int(max) + 1023) / 1024
			self.BuildVariant.AddOperation(raptor_data.Set(varname+"MIN_DEC_KB", "%d" % min_dec_kb))
			self.__debug("Set "+varname+"MIN  OPTION KB to '%d' (dec)" % min_dec_kb )
			self.BuildVariant.AddOperation(raptor_data.Set(varname+"MAX_DEC_KB", "%d" % max_dec_kb))
			self.__debug("Set "+varname+"MAX  OPTION KB to '%d' (dec)" % max_dec_kb )

		elif varname=='EPOCSTACKSIZE':
			if toks[1].lower().startswith('0x'):
				stack = long(toks[1],16)
			else:
				stack = long(toks[1],10)
			self.BuildVariant.AddOperation(raptor_data.Set(varname, "%x" % stack))
			self.__debug("Set "+varname+"  OPTION to '%x' (hex)" % stack  )
		elif varname=='EPOCPROCESSPRIORITY':
			# low, background, foreground, high, windowserver, fileserver, realtimeserver or supervisor
			# These are case insensitive in metadata entries, but must be mapped to a static case pattern for use
			prio = toks[1].lower()

			# NOTE: Original validation here didn't actually work.  This has been corrected to provide an error, but probably needs re-examination.
			if not MMPRaptorBackend.epoc32priorities.has_key(prio):
				self.__Raptor.Error("Priority setting '%s' is not a valid priority - should be one of %s.", prio, MMPRaptorBackend.epoc32priorities.values())
			else:
				self.__debug("Set "+toks[0]+" to " +  MMPRaptorBackend.epoc32priorities[prio])
				self.BuildVariant.AddOperation(raptor_data.Set(varname,MMPRaptorBackend.epoc32priorities[prio]))
		elif varname=='ROMTARGET' or varname=='RAMTARGET':
			if len(toks) == 1:
				self.__debug("Set "+toks[0]+" to <none>" )
				self.BuildVariant.AddOperation(raptor_data.Set(varname,"<none>"))
			else:
				toks1 = str(toks[1]).replace("\\","/")
				if toks1.find(","):
					toks1 = re.sub("[,'\[\]]", "", toks1).replace("//","/")
				self.__debug("Set "+toks[0]+" to " + toks1)
				self.BuildVariant.AddOperation(raptor_data.Set(varname,toks1))
				
		elif varname == 'TRACES':
			self.__debug("Set " + toks[0] + " to 1" )
			self.BuildVariant.AddOperation(raptor_data.Set(varname, "1"))
			
			if len(toks) == 1:
				toks1 = "../traces"
			else:
				toks1 = os.path.join(toks[1], "traces").replace("\\","/")
			path = toks1 + "/" + self.__TARGET + "_" + self.__TARGETEXT
			resolved = raptor_utilities.resolveSymbianPath(self.__currentMmpFile, path)
			self.BuildVariant.AddOperation(raptor_data.Append('USERINCLUDE', resolved))
			self.__userinclude += ' ' + resolved
			self.__debug("  %s = %s", "USERINCLUDE", self.__userinclude)
		
		elif varname=='APPLY':
			self.ApplyVariants.append(toks[1])
		elif varname=='ARMFPU':
			if not str(toks[1]).lower() in self.armfpu_options:
				self.__Raptor.Error("ARMFPU option '"+str(toks[1])+"' not recognised - should be one of "+", ".join(self.armfpu_options))
			else:
				self.__debug("Set "+toks[0]+" to " + str(toks[1]))
				self.BuildVariant.AddOperation(raptor_data.Set(varname,str(toks[1])))
		else:
			self.__debug("Set "+toks[0]+" to " + str(toks[1]))
			self.BuildVariant.AddOperation(raptor_data.Set(varname,"".join(toks[1])))

			if varname=='LINKAS':
				self.__LINKAS = toks[1]

		return "OK"

	def doAppend(self,s,loc,toks):
		self.__currentLineNumber += 1
		"""MMP command
		"""
		name=toks[0].upper()
		if len(toks) == 1:
			# list can be empty e.g. MACRO _FRED_ when fred it defined in the HRH
			# causes us to see just "MACRO" in the input - it is valid to ignore this
			self.__debug("Empty append list for " + name)
			return "OK"
		self.__debug("Append to "+name+" the values: " +str(toks[1]))

		if name=='MACRO':
			name='MMPDEFS'
		elif name=='LANG':
			# don't break the environment variable
			name='LANGUAGES'

		for item in toks[1]:
			if name=='MMPDEFS':
				# Unquote any macros since the FLM does it anyhow
				if item.startswith('"') and item.endswith('"') \
				or item.startswith("'") and item.endswith("'"):
					item = item.strip("'\"")
			if name=='LIBRARY' or name=='DEBUGLIBRARY':
				im = MMPRaptorBackend.library_re.match(item)
				if not im:
					self.__error("LIBRARY: %s Seems to have an invalid name.\nExpected xxxx.lib or xxxx.dso\n where xxxx might be\n\tname or \n\tname(n,m) where n is a major version number and m is a minor version number\n" %item)
				d = im.groupdict()

				item = d['name']
				if d['version'] is not None:
					item += "{%04x%04x}" % (int(d['major']), int(d['minor']))
				item += ".dso"
			elif name=='STATICLIBRARY':
				# the FLM will decide on the ending appropriate to the platform
				item = re.sub(r"^(.*)\.[Ll][Ii][Bb]$",r"\1", item)
			elif name=="LANGUAGES":
				item = item.lower()
			elif (name=="WIN32_LIBRARY" and (item.startswith(".") or re.search(r'[\\|/]',item))) \
				or (name=="WIN32_RESOURCE"):
				# Relatively pathed win32 libraries, and all win32 resources, are resolved in relation
				# to the wrapper bld.inf file in which their .mmp file is specified.  This equates to
				# the current working directory in ABLD operation.
				item = raptor_utilities.resolveSymbianPath(self.__bldInfFilename, item)
				
			self.BuildVariant.AddOperation(raptor_data.Append(name,item," "))
			
			# maintain a debug library list, the same as LIBRARY but with DEBUGLIBRARY values
			# appended as they are encountered
			if name=='LIBRARY' or name=='DEBUGLIBRARY':
				self.BuildVariant.AddOperation(raptor_data.Append("LIBRARY_DEBUG",item," "))			

		return "OK"

	def canonicalUID(number):
		""" convert a UID string into an 8 digit hexadecimal string without leading 0x """
		if number.lower().startswith("0x"):
			n = int(number,16)
		else:
			n = int(number,10)

		return "%08x" % n

	canonicalUID = staticmethod(canonicalUID)

	def doUIDAssignment(self,s,loc,toks):
		"""A single UID command results in a number of spec variables"""
		self.__currentLineNumber += 1

		hexoutput = MMPRaptorBackend.canonicalUID(toks[1][0])
		self.__debug( "Set UID2 to %s" % hexoutput )
		self.BuildVariant.AddOperation(raptor_data.Set("UID2", hexoutput))

		if len(toks[1]) > 1:
			hexoutput = MMPRaptorBackend.canonicalUID(toks[1][1])
			self.__debug( "Set UID3 to %s" % hexoutput)
			self.BuildVariant.AddOperation(raptor_data.Set("UID3", hexoutput))

		self.__debug( "done set UID")
		return "OK"

	def doSourcePathAssignment(self,s,loc,toks):
		self.__currentLineNumber += 1
		self.__sourcepath = raptor_utilities.resolveSymbianPath(self.__currentMmpFile, toks[1])
		self.__debug( "Remembering self.sourcepath state:  "+str(toks[0])+" is now " + self.__sourcepath)
		self.__debug("selfcurrentMmpFile: " + self.__currentMmpFile)
		return "OK"
	
	def __doAssignment(self,filelist,toks):
		""" Ancillary method factorying out the common functionality between doSourceAssignment
		and doDocumentAssignment. Arguments are
		filelist - list to append items to, should be self.sources or self.documents 
		toks - toks parameter as passed from PyParsing. """
		
		self.__currentLineNumber += 1
		self.__debug( "Setting "+toks[0]+" to " + str(toks[1]))
		for file in toks[1]:
			# file is always relative to sourcepath but some MMP files
			# have items that begin with a slash...
			file = file.lstrip("/")
			source = generic_path.Join(self.__sourcepath, file)

			# If the SOURCEPATH itself begins with a '/', then dont look up the caseless version, since
			# we don't know at this time what $(EPOCROOT) will evaluate to.
			if source.GetLocalString().startswith('$(EPOCROOT)'):
				filelist.append(str(source))						
				self.__debug("Append " + toks[0] + " " + str(source))

			else:
				foundsource = source.FindCaseless()
				if foundsource == None:
					# Hope that the file will be generated later
					self.__debug("%s file not found: %s" % (toks[0], source))
					foundsource = source

				filelist.append(str(foundsource))					
				self.__debug("Append " + toks[0] + " " + str(foundsource))


		self.__debug("		sourcepath: " + self.__sourcepath)
		return "OK"

	def doSourceAssignment(self,s,loc,toks):
		""" Populate the list of source files from the MMP. """
		self.__doAssignment(self.sources,toks)

	def doDocumentAssignment(self,s,loc,toks):
		""" Populate the list of document files from the MMP. """
		self.__doAssignment(self.documents,toks)

	# Resource

	def doOldResourceAssignment(self,s,loc,toks):
		# Technically deprecated, but still used, so...
		self.__currentLineNumber += 1
		self.__debug("Processing old-style "+toks[0]+" "+str(toks[1]))

		sysRes = (toks[0].lower() == "systemresource")

		for rss in toks[1]:
			variant = raptor_data.Variant()

			source = generic_path.Join(self.__sourcepath, rss)
			variant.AddOperation(raptor_data.Set("SOURCE", str(source)))
			self.__resourceFiles.append(str(source))

			target = source.File().rsplit(".", 1)[0]	# remove the extension
			variant.AddOperation(raptor_data.Set("TARGET", target))
			variant.AddOperation(raptor_data.Set("TARGET_lower", target.lower()))

			header = target.lower() + ".rsg"			# filename policy
			variant.AddOperation(raptor_data.Set("HEADER", header))

			if sysRes:
				dsrtp = self.getDefaultSystemResourceTargetPath()
				variant.AddOperation(raptor_data.Set("TARGETPATH", dsrtp))

			self.ResourceVariants.append(variant)

		return "OK"

	def getDefaultSystemResourceTargetPath(self):
		# the default systemresource TARGETPATH value should come from the
		# configuration rather than being hard-coded here. Then again, this
		# should really be deprecated away into oblivion...
		return "system/data"


	def getDefaultResourceTargetPath(self, targettype):
		# the different default TARGETPATH values should come from the
		# configuration rather than being hard-coded here.
		if targettype in ["plugin", "plugin3"]:
			return "resource/plugins"
		if targettype == "pdl":
			return "resource/printers"
		return ""

	def resolveOptionReplace(self, content):
		"""
		Constructs search/replace pairs based on .mmp OPTION_REPLACE entries for use on tool command lines
		within FLMS.

		Depending on what's supplied to OPTION_REPLACE <TOOL>, the core part of the <TOOL> command line
		in the relevant FLM will have search and replace actions performed on it post-expansion (but pre-
		any OPTION <TOOL> additions).

		In terms of logic, we try to follow what ABLD does, as the current behaviour is undocumented.
		What happens is a little inconsistent, and best described by some generic examples:

			OPTION_REPLACE TOOL existing_option replacement_value

				Replace all instances of "option existing_value" with "option replacement_value"

			OPTION_REPLACE TOOL existing_option replacement_option

				Replace all instances of "existing_option" with "replacement_option".

			If "existing_option" is present in isolation then a removal is performed.

		Any values encountered that don't follow an option are ignored.
		Options are identified as being prefixed with either '-' or '--'.

		The front-end processes each OPTION_REPLACE entry and then appends one or more search/replace pairs
		to an OPTION_REPLACE_<TOOL> variable in the following format:

		     search<->replace
		"""
		# Note that, for compatibility reasons, the following is mostly a port to Python of the corresponding
		# ABLD Perl, and hence maintains ABLD's idiosyncrasies in what it achieves

		searchReplacePairs = []
		matches = re.findall("-{1,2}\S+\s*(?!-)\S*",content)

		if matches:
			# reverse so we can process as a stack whilst retaining original order
			matches.reverse()

			while (len(matches)):
				match = matches.pop()

				standaloneMatch = re.match('^(?P<option>\S+)\s+(?P<value>\S+)$', match)

				if (standaloneMatch):
					# Option listed standalone with a replacement value
					# Example:
					# 	OPTION_REPLACE ARMCC --cpu 6
					# Intention:
					# 	Replace instances of  "--cpu <something>" with "--cpu 6"

					# Substitute any existing "option <existing_value>" instances with a single word
					# "@@<existing_value>" for later replacement
					searchReplacePairs.append('%s <->@@' % standaloneMatch.group('option'))

					# Replace "@@<existing_value>" entries from above with "option <new_value>" entries
					# A pattern substitution is used to cover pre-existing values
					searchReplacePairs.append('@@%%<->%s %s' % (standaloneMatch.group('option'), standaloneMatch.group('value')))
				else:
					# Options specified in search/replace pairs with optional values
					# Example:
					#	OPTION_REPLACE ARMCC --O2 --O3
					# Intention:
					#	Replace instances of "--O2" with "--O3"

					# At this point we will be looking at just the search option - there may or may not
					# be a replacement to consider
					search = match
					replace = ""
					if len(matches):
						replace = matches.pop()

					searchReplacePairs.append('%s<->%s' % (search, replace))

			# Replace spaces to maintain word-based grouping in downstream makefile lists
			for i in range(0,len(searchReplacePairs)):
				searchReplacePairs[i] = searchReplacePairs[i].replace(' ','%20')

		return searchReplacePairs

	def doStartResource(self,s,loc,toks):
		self.__currentLineNumber += 1
		self.__debug("Start RESOURCE "+toks[1])

		self.__current_resource = generic_path.Path(self.__sourcepath, toks[1])
		self.__current_resource = str(self.__current_resource)

		self.__debug("sourcepath: " + self.__sourcepath)
		self.__debug("self.__current_resource source: " + toks[1])
		self.__debug("adjusted self.__current_resource source=" + self.__current_resource)

		self.__currentResourceVariant = raptor_data.Variant()
		self.__currentResourceVariant.AddOperation(raptor_data.Set("SOURCE", self.__current_resource))
		self.__resourceFiles.append(self.__current_resource)

		# The target name is the basename of the resource without the extension
		# e.g. "/fred/129ab34f.rss" would have a target name of "129ab34f"
		target = self.__current_resource.rsplit("/",1)[-1]
		target = target.rsplit(".",1)[0]
		self.__currentResourceVariant.AddOperation(raptor_data.Set("TARGET", target))
		self.__currentResourceVariant.AddOperation(raptor_data.Set("TARGET_lower", target.lower()))
		self.__headerspecified = False
		self.__headeronlyspecified = False
		self.__current_resource_header = target.lower() + ".rsg"

		return "OK"

	def doResourceAssignment(self,s,loc,toks):
		""" Assign variables for resource files """
		self.__currentLineNumber += 1
		varname = toks[0].upper() # the mmp keyword
		varvalue = "".join(toks[1])

		# Get rid of any .rsc extension because the build system
		# needs to have it stripped off to calculate other names
		# for other purposes and # we aren't going to make it
		# optional anyhow.
		if varname == "TARGET":
			target_withext = varvalue.rsplit("/\\",1)[-1]
			target = target_withext.rsplit(".",1)[0]
			self.__current_resource_header = target.lower() + ".rsg"
			self.__currentResourceVariant.AddOperation(raptor_data.Set("TARGET_lower", target.lower()))
			self.__debug("Set resource "+varname+" to " + target)
			self.__currentResourceVariant.AddOperation(raptor_data.Set(varname,target))
		if varname == "TARGETPATH":
			varvalue=varvalue.replace('\\','/')
			self.__debug("Set resource "+varname+" to " + varvalue)
			self.__currentResourceVariant.AddOperation(raptor_data.Set(varname,varvalue))
		else:
			self.__debug("Set resource "+varname+" to " + varvalue)
			self.__currentResourceVariant.AddOperation(raptor_data.Set(varname,varvalue))
		return "OK"

	def doResourceAppend(self,s,loc,toks):
		self.__currentLineNumber += 1
		self.__debug("Append resource to "+toks[0]+" the values: " +str(toks[1]))
		varname = toks[0].upper()

		# we cannot use LANG as it interferes with the environment
		if varname == "LANG":
			varname = "LANGUAGES"

		for item in toks[1]:
			if varname == "LANGUAGES":
				item = item.lower()
			self.__currentResourceVariant.AddOperation(raptor_data.Append(varname,item))
		return "OK"

	def doResourceSetSwitch(self,s,loc,toks):
		self.__currentLineNumber += 1
		name = toks[0].upper()

		if name == "HEADER":
			self.__headerspecified = True

		elif name == "HEADERONLY":
			self.__headeronlyspecified = True

		else:
			value = "1"
			self.__debug( "Set resource switch " + name + " " + value)
			self.__currentResourceVariant.AddOperation(raptor_data.Set(name, value))

		return "OK"

	def doEndResource(self,s,loc,toks):
		self.__currentLineNumber += 1

		# Header name can change, depening if there was a TARGET defined or not, so it must be appended at the end
		if self.__headerspecified:
			self.__debug("Set resource switch HEADER " + self.__current_resource_header)
			self.__currentResourceVariant.AddOperation(raptor_data.Set("HEADER", self.__current_resource_header))

		if self.__headeronlyspecified:
			self.__debug("Set resource switch HEADERONLY " + self.__current_resource_header)
			self.__currentResourceVariant.AddOperation(raptor_data.Set("HEADER", self.__current_resource_header))
			self.__currentResourceVariant.AddOperation(raptor_data.Set("HEADERONLY", "True"))

		self.__debug("End RESOURCE")
		self.ResourceVariants.append(self.__currentResourceVariant)
		self.__currentResourceVariant = None
		self.__current_resource = ""
		return "OK"

	# Bitmap

	def doStartBitmap(self,s,loc,toks):
		self.__currentLineNumber += 1
		self.__debug("Start BITMAP "+toks[1])

		self.__currentBitmapVariant = raptor_data.Variant(name = toks[1].replace('.','_'))
		# Use BMTARGET and BMTARGET_lower because that prevents
		# confusion with the TARGET and TARGET_lower of our parent MMP
		# when setting the OUTPUTPATH.  This in turn allows us to
		# not get tripped up by multiple mbms being generated with
		# the same name to the same directory.
		self.__currentBitmapVariant.AddOperation(raptor_data.Set("BMTARGET", toks[1]))
		self.__currentBitmapVariant.AddOperation(raptor_data.Set("BMTARGET_lower", toks[1].lower()))
		self.__currentBitmapVariant.AddOperation(raptor_data.Set("SOURCE", ""))
		return "OK"

	def doBitmapAssignment(self,s,loc,toks):
		self.__currentLineNumber += 1
		self.__debug("Set bitmap "+toks[0]+" to " + str(toks[1]))
		name = toks[0].upper()
		value = "".join(toks[1])
		if name == "TARGETPATH":
			value = value.replace('\\','/')

		self.__currentBitmapVariant.AddOperation(raptor_data.Set(name,value))
		return "OK"

	def doBitmapSourcePathAssignment(self,s,loc,toks):
		self.__currentLineNumber += 1
		self.__debug("Previous bitmap sourcepath:" + self.__bitmapSourcepath)
		self.__bitmapSourcepath = raptor_utilities.resolveSymbianPath(self.__currentMmpFile, toks[1])
		self.__debug("New bitmap sourcepath: " + self.__bitmapSourcepath)

	def doBitmapSourceAssignment(self,s,loc,toks):
		self.__currentLineNumber += 1
		self.__debug( "Setting "+toks[0]+" to " + str(toks[1]))
		# The first "source" is the colour depth for all the others.
		# The depth format is b[,m] where b is the bitmap depth and m is
		# the mask depth.
		# Valid values for b are: 1 2 4 8 c4 c8 c12 c16 c24 c32 c32a (?)
		# Valid values for m are: 1 8 (any number?)
		#
		# If m is specified then the bitmaps are in pairs: b0 m0 b1 m1...
		# If m is not specified then there are no masks, just bitmaps: b0 b1...
		colordepth = toks[1][0].lower()
		if "," in colordepth:
			(bitmapdepth, maskdepth) = colordepth.split(",")
		else:
			bitmapdepth = colordepth
			maskdepth = 0

		sources=""
		mask = False
		for file in toks[1][1:]:
			path = generic_path.Join(self.__bitmapSourcepath, file)
			if sources:
				sources += " "
			if mask:
				sources += "DEPTH=" + maskdepth + " FILE=" + str(path)
			else:
				sources += "DEPTH=" + bitmapdepth + " FILE=" + str(path)
			if maskdepth:
				mask = not mask
		self.__debug("sources: " + sources)
		self.__currentBitmapVariant.AddOperation(raptor_data.Append("SOURCE", sources))
		return "OK"

	def doBitmapSetSwitch(self,s,loc,toks):
		self.__currentLineNumber += 1
		self.__debug( "Set bitmap switch "+toks[0]+" ON")
		self.__currentBitmapVariant.AddOperation(raptor_data.Set(toks[0].upper(), "1"))
		return "OK"

	def doEndBitmap(self,s,loc,toks):
		self.__currentLineNumber += 1
		self.__bitmapSourcepath = self.__sourcepath
		self.BitmapVariants.append(self.__currentBitmapVariant)
		self.__currentBitmapVariant = None
		self.__debug("End BITMAP")
		return "OK"

	# Stringtable

	def doStartStringTable(self,s,loc,toks):
		self.__currentLineNumber += 1
		self.__debug( "Start STRINGTABLE "+toks[1])

		specstringtable = generic_path.Join(self.__sourcepath, toks[1])
		uniqname = specstringtable.File().replace('.','_') # corrected, filename only
		source = str(specstringtable.FindCaseless())

		self.__debug("sourcepath: " + self.__sourcepath)
		self.__debug("stringtable: " + toks[1])
		self.__debug("adjusted stringtable source=" + source)

		self.__currentStringTableVariant = raptor_data.Variant(name = uniqname)
		self.__currentStringTableVariant.AddOperation(raptor_data.Set("SOURCE", source))
		self.__currentStringTableVariant.AddOperation(raptor_data.Set("EXPORTPATH", ""))
		self.__stringtableExported = False

		# The target name by default is the name of the stringtable without the extension
		# e.g. the stringtable "/fred/http.st" would have a default target name of "http"
		stringtable_withext = specstringtable.File()
		self.__stringtable = stringtable_withext.rsplit(".",1)[0].lower()
		self.__currentStringTableVariant.AddOperation(raptor_data.Set("TARGET", self.__stringtable))

		self.__stringtableHeaderonlyspecified = False

		return "OK"

	def doStringTableAssignment(self,s,loc,toks):
		""" Assign variables for stringtables """
		self.__currentLineNumber += 1
		varname = toks[0].upper() # the mmp keyword
		varvalue = "".join(toks[1])

		# Get rid of any .rsc extension because the build system
		# needs to have it stripped off to calculate other names
		# for other purposes and # we aren't going to make it
		# optional anyhow.
		if varname == "EXPORTPATH":
			finalvalue = raptor_utilities.resolveSymbianPath(self.__currentMmpFile, varvalue)
			self.__stringtableExported = True
		else:
			finalvalue = varvalue

		self.__debug("Set stringtable "+varname+" to " + finalvalue)
		self.__currentStringTableVariant.AddOperation(raptor_data.Set(varname,finalvalue))
		return "OK"

	def doStringTableSetSwitch(self,s,loc,toks):
		self.__currentLineNumber += 1
		if toks[0].upper()== "HEADERONLY":
			self.__stringtableHeaderonlyspecified = True
			self.__debug( "Set stringtable switch "+toks[0]+" ON")
			self.__currentStringTableVariant.AddOperation(raptor_data.Set(toks[0].upper(), "1"))
		return "OK"

	def doEndStringTable(self,s,loc,toks):
		self.__currentLineNumber += 1

		if not self.__stringtableExported:
			# There was no EXPORTPATH specified for this stringtable
			# so for our other code to be able to reference it we
			# must add the path of the generated location to the userinclude path

			ipath = "$(OUTPUTPATH)"
			self.BuildVariant.AddOperation(raptor_data.Append("USERINCLUDE",ipath))
			self.__userinclude += ' ' + ipath
			self.__debug("  USERINCLUDE = %s", self.__userinclude)
			self.__userinclude.strip()

		self.StringTableVariants.append(self.__currentStringTableVariant)
		self.__currentStringTableVariant = None
		self.__debug("End STRINGTABLE")
		if not self.__stringtableHeaderonlyspecified:
			# Have to assume that this is where the cpp file will be.  This has to be maintained
			# in sync with the FLM's idea of where this file should be.  We need a better way.
			# Interfaces also need outputs that allow other interfaces to refer to their outputs
			# without having to "know" where they will be.
			self.sources.append('$(OUTPUTPATH)/' + self.__stringtable + '.cpp')
		return "OK"


	def doUnknownStatement(self,s,loc,toks):
		self.__warn("%s (%d) : Unrecognised Keyword %s", self.__currentMmpFile, self.__currentLineNumber, str(toks))
		self.__currentLineNumber += 1
		return "OK"


	def doUnknownBlock(self,s,loc,toks):
		self.__warn("%s (%d) : Unrecognised Block %s", self.__currentMmpFile, self.__currentLineNumber, str(toks))
		self.__currentLineNumber += 1
		return "OK"

	def doDeprecated(self,s,loc,toks):
		self.__debug( "Deprecated command " + str(toks))
		self.__warn("%s (%d) : %s is deprecated .mmp file syntax", self.__currentMmpFile, self.__currentLineNumber, str(toks))
		self.__currentLineNumber += 1
		return "OK"

	def doNothing(self):
		self.__currentLineNumber += 1
		return "OK"

	def finalise(self, aBuildPlatform):
		"""Post-processing of data that is only applicable in the context of a fully
		processed .mmp file."""
		resolvedDefFile = ""

		if self.__TARGET:
			defaultRootName = self.__TARGET
			if self.__TARGETEXT!="":
				defaultRootName += "." + self.__TARGETEXT

			# NOTE: Changing default .def file name based on the LINKAS argument is actually
			# a defect, but this follows the behaviour of the current build system.
			if (self.__LINKAS):
				defaultRootName = self.__LINKAS

			(resolvedDefFile, isSecondaryDefFile) = self.resolveDefFile(defaultRootName, aBuildPlatform)
			# We need to store the resolved .def file and location for the FREEZE target
			self.__debug("Resolved def file:  %s" % resolvedDefFile )
			self.BuildVariant.AddOperation(raptor_data.Set("RESOLVED_DEFFILE", resolvedDefFile))
			# We need to store the primary/secondary status of the resolved .def file as some configurations
			# require additional processing based on the result
			secondaryDefFile = ""
			if isSecondaryDefFile:
				secondaryDefFile = "1"
			self.__debug("Set RESOLVED_DEFFILE_SECONDARY to '%s'" % secondaryDefFile)
			self.BuildVariant.AddOperation(raptor_data.Set("RESOLVED_DEFFILE_SECONDARY", secondaryDefFile))

		# If a deffile is specified, an FLM will put in a dependency.
		# If a deffile is specified then raptor_meta will guess a name but:
		#	1) If the guess is wrong then the FLM will complain "no rule to make ..."
		#	2) In some cases, e.g. plugin, 1) is not desirable as the presence of a def file
		#		is not a necessity.  In these cases the FLM needs to know if DEFFILE
		#		is a guess or not so it can decide if a dependency should be added.

		# We check that the def file exists and that it is non-zero (incredible
		# that this should be needed).

		deffile_keyword="1"
		if self.deffile == "":
			# If the user didn't specify a deffile name then
			# we must be guessing
			# Let's check if our guess actually corresponds to a
			# real file.  If it does then that confims the guess.
			#  If there's no file then we still need to pass make the name
			# so it can complain about there not being a DEF file
			# for this particular target type and fail to build this target.

			deffile_keyword=""
			try:
				findpath = generic_path.Path(resolvedDefFile)
				foundfile = findpath.FindCaseless()

				if foundfile == None:
					raise IOError("file not found")

				self.__debug("Found DEFFILE  " + foundfile.GetLocalString())
				rfstat = os.stat(foundfile.GetLocalString())

				mode = rfstat[stat.ST_MODE]
				if mode != None and stat.S_ISREG(mode) and rfstat[stat.ST_SIZE] > 0:
					resolvedDefFile = str(foundfile)
				else:
					resolvedDefFile=""
			except Exception,e:
				self.__debug("While Searching for an IMPLIED  DEFFILE: %s: %s" % (str(e),str(findpath)) )
				resolvedDefFile=""
		else:
			if not resolvedDefFile == "":
				try:
					findpath = generic_path.Path(resolvedDefFile)
					resolvedDefFile = str(findpath.FindCaseless())
					if resolvedDefFile=="None":
						raise IOError("file not found")
				except Exception,e:
					self.__warn("While Searching for a SPECIFIED DEFFILE: %s: %s" % (str(e),str(findpath)) )
					resolvedDefFile=""
			else:
				self.__warn("DEFFILE KEYWORD used (%s) but def file not resolved" % (self.deffile) )


		self.BuildVariant.AddOperation(raptor_data.Set("DEFFILE", resolvedDefFile))
		self.__debug("Set DEFFILE to " + resolvedDefFile)
		self.BuildVariant.AddOperation(raptor_data.Set("DEFFILEKEYWORD", deffile_keyword))
		self.__debug("Set DEFFILEKEYWORD to '%s'",deffile_keyword)

		# If target type is "implib" it must have a def file
		self.checkImplibDefFile(resolvedDefFile)

		# if this target type has a default TARGETPATH other than "" for
		# resources then we need to add that default to all resources which
		# do not explicitly set the TARGETPATH themselves.
		tp = self.getDefaultResourceTargetPath(self.getTargetType())
		if tp:
			for i,var in enumerate(self.ResourceVariants):
				# does this resource specify its own TARGETPATH?
				needTP = True
				for op in var.ops:
					if isinstance(op, raptor_data.Set) \
					and op.name == "TARGETPATH":
						needTP = False
						break
				if needTP:
					self.ResourceVariants[i].AddOperation(raptor_data.Set("TARGETPATH", tp))

		# some core build configurations need to know about the resource builds, and
		# some resource building configurations need knowledge of the core build
		for resourceFile in self.__resourceFiles:
			self.BuildVariant.AddOperation(raptor_data.Append("RESOURCEFILES", resourceFile))

		for i,var in enumerate(self.ResourceVariants):
			self.ResourceVariants[i].AddOperation(raptor_data.Set("MAIN_TARGET_lower", self.__TARGET.lower()))
			self.ResourceVariants[i].AddOperation(raptor_data.Set("MAIN_REQUESTEDTARGETEXT", self.__TARGETEXT.lower()))

		# Create Capability variable in one SET operation (more efficient than multiple appends)
		
		self.BuildVariant.AddOperation(raptor_data.Set("CAPABILITY","".join(self.capabilities)))

		# Resolve combined capabilities as hex flags, for configurations that require them
		capabilityFlag1 = 0
		capabilityFlag2 = 0			# Always 0

		for capability in self.capabilities:
			invert = 0

			if capability.startswith('-'):
				invert = 0xffffffff
			capability = capability[1:]

			if MMPRaptorBackend.supportedCapabilities.has_key(capability):
				capabilityFlag1 = capabilityFlag1 ^ invert
				capabilityFlag1 = capabilityFlag1 | MMPRaptorBackend.supportedCapabilities[capability]
				capabilityFlag1 = capabilityFlag1 ^ invert

		capabilityFlag1 = "%08xu" % capabilityFlag1
		capabilityFlag2 = "%08xu" % capabilityFlag2

		self.BuildVariant.AddOperation(raptor_data.Set("CAPABILITYFLAG1", capabilityFlag1))
		self.__debug ("Set CAPABILITYFLAG1 to " + capabilityFlag1)
		self.BuildVariant.AddOperation(raptor_data.Set("CAPABILITYFLAG2", capabilityFlag2))
		self.__debug ("Set CAPABILITYFLAG2 to " + capabilityFlag2)

		# For non-Feature Variant builds, the location of the product include hrh file is
		# appended to the SYSTEMINCLUDE list
		if not aBuildPlatform['ISFEATUREVARIANT']:
			productIncludePath = str(aBuildPlatform['VARIANT_HRH'].Dir())
			self.BuildVariant.AddOperation(raptor_data.Append("SYSTEMINCLUDE",productIncludePath))
			self.__debug("Appending product include location %s to SYSTEMINCLUDE",productIncludePath)

		# Specifying both a PAGED* and its opposite UNPAGED* keyword in a .mmp file
		# will generate a warning and the last keyword specified will take effect.
		self.__pageConflict.reverse()
		if "PAGEDCODE" in self.__pageConflict and "UNPAGEDCODE" in self.__pageConflict:
			for x in self.__pageConflict:
				if x == "PAGEDCODE" or x == "UNPAGEDCODE":
					self.__Raptor.Warn("Both PAGEDCODE and UNPAGEDCODE are specified. The last one %s will take effect" % x)
					if x == "PAGEDCODE":
						self.resolveCompressionKeyword("BYTEPAIRCOMPRESSTARGET")
					break
		elif "PAGEDCODE" in self.__pageConflict:
			self.resolveCompressionKeyword("BYTEPAIRCOMPRESSTARGET")
				
		if "PAGEDDATA" in self.__pageConflict and "UNPAGEDDATA" in self.__pageConflict:
			for x in self.__pageConflict:
				if x == "PAGEDDATA" or x == "UNPAGEDDATA":
					self.__Raptor.Warn("Both PAGEDDATA and UNPAGEDDATA are specified. The last one %s will take effect" % x)
					if x == "PAGEDDATA":
						self.resolveCompressionKeyword("BYTEPAIRCOMPRESSTARGET")
					break
		elif "PAGEDDATA" in self.__pageConflict:
			self.resolveCompressionKeyword("BYTEPAIRCOMPRESSTARGET")

		# Set Debuggable
		self.BuildVariant.AddOperation(raptor_data.Set("DEBUGGABLE", self.__debuggable))

		if self.__explicitversion:
			self.BuildVariant.AddOperation(raptor_data.Append("UNIQUETARGETPATH","$(TARGET_lower)_$(VERSIONHEX)_$(REQUESTEDTARGETEXT)",'/'))
		else:
			self.BuildVariant.AddOperation(raptor_data.Append("UNIQUETARGETPATH","$(TARGET_lower)_$(REQUESTEDTARGETEXT)",'/'))

		# Put the list of sourcefiles in with one Set operation - saves memory
		# and performance over using multiple Append operations.
		self.BuildVariant.AddOperation(raptor_data.Set("SOURCE",
						   " ".join(self.sources)))
		
		# Put the list of document files in with one Set operation - saves memory
		# and performance over using multiple Append operations.
		self.BuildVariant.AddOperation(raptor_data.Set("DOCUMENT",
						   " ".join(self.documents)))


	def validate(self):
		"""Test that the parsed MMP file is correct.
		
		By "correct" we mean that all the required keywords were present
		with acceptable and mutually consistent values.
		
		There should be no attempt to build anything if this method returns False."""
		
		# do all the checks so that we can see all the errors at once...
		valid = True
		
		# for "TARGETTYPE none", it is permitted to omit the "TARGET" keyword
		if not self.__TARGET and not self.getTargetType() == "none":
			self.__Raptor.Error("required keyword TARGET is missing in " + self.__currentMmpFile, bldinf=self.__bldInfFilename)
			valid = False
		
		# what else could be wrong?
			
		return valid
	
	def getTargetType(self):
		"""Target type in lower case - the standard format"""
		return self.__targettype.lower()

	def resolveCompressionKeyword(self, aCompressionKeyword):
		"""If a compression keyword is set more than once either explicitly
		or implicitly a warning is given and the last one takes effect 
		"""
		if self.__compressionKeyword and self.__compressionKeyword != aCompressionKeyword:
			self.__Raptor.Warn("%s keyword in %s overrides earlier use of %s" % \
						(aCompressionKeyword, self.__currentMmpFile, self.__compressionKeyword))
			self.BuildVariant.AddOperation(raptor_data.Set(self.__compressionKeyword, ""))
			self.__debug( "Set switch " + self.__compressionKeyword + " OFF")
		self.BuildVariant.AddOperation(raptor_data.Set(aCompressionKeyword,"1"))
		self.__debug( "Set switch " + aCompressionKeyword + " ON")
		self.__compressionKeyword = aCompressionKeyword

	def checkImplibDefFile(self, defFile):
		"""Project with target type implib must have DEFFILE defined 
		explicitly or implicitly, otherwise it is an error
		""" 
		if self.getTargetType() == 'implib' and defFile == '':
			self.__Raptor.Error("No DEF File for IMPLIB target type in " + \
							self.__currentMmpFile, bldinf=self.__bldInfFilename)

	def resolveDefFile(self, aTARGET, aBuildPlatform):
		"""Returns a fully resolved DEFFILE entry depending on .mmp file location and TARGET, DEFFILE and NOSTRICTDEF
		entries in the .mmp file itself (where appropriate).
		Is able to deal with target names that have multiple '.' characters e.g. messageintercept.esockdebug.dll
		Supports configurations that allow primary and secondary .def file locations.
		"""

		resolvedDefFile = ""
		platform = aBuildPlatform['PLATFORM']
		isSecondaryDefaultDefFile = False

		# Not having a default .def file directory is a pretty strong indicator that
		# .def files aren't supported for the particular platform
		if PlatformDefaultDefFileDir.has_key(platform):
			
			# Some configurations support both primary and secondary default .def file locations - we need to take this
			# into account in resolving .def file locations
			primaryDefaultDefFileDir = PlatformDefaultDefFileDir[platform]
			secondaryDefaultDefFileDir = ""
			
			if type(PlatformDefaultDefFileDir[platform]) == list:
				(primaryDefaultDefFileDir, secondaryDefaultDefFileDir) = PlatformDefaultDefFileDir[platform]
			
			(targetname,targetext) = os.path.splitext(aTARGET)
			(defname,defext) = os.path.splitext(self.deffile)
			if defext=="":
				defext = ".def"

			# NOTE: WORKAROUND
			if len(targetext) > 4:
				targetname += defext

			if not self.deffile:
				# No DEFFILE entry - expected .def filename will be based on the target name
				resolvedDefFile = targetname
			else:
				# DEFFILE listed - take into account the value, depending on what format it takes
				if re.search('[\\|\/]$', self.deffile):
					# If DEFFILE is *solely* a path, signified by ending in a slash, then TARGET is the
					# basis for the default .def filename but with the specified path as prefix
					resolvedDefFile = self.deffile + targetname
				else:
					resolvedDefFile = defname

				resolvedDefFile = resolvedDefFile.replace('~', primaryDefaultDefFileDir)

			if not self.nostrictdef:
				resolvedDefFile += 'u'

			if self.__explicitversion:
				resolvedDefFile += '{' + self.__versionhex + '}'

			resolvedDefFile += defext

			# If the resolved .def file we have so far doesn't include a path in any shape or form, we prepend the default,
			# implicit, .def file location based on the configuration being built
			if not re.search('[\\\/]+', self.deffile):
				resolvedDefFile = '../'+primaryDefaultDefFileDir+'/'+resolvedDefFile
				
			# Some configurations support a secondary, "fall back", .def file location if a .def file doesn't physically
			# exist at the primary location.
			# We therefore check exisitance of the primary located file if a secondary location is available, and use the
			# secondary location if required (recording the fact that the secondary file has been used, as this can influence
			# downstream processing).
			# Secondary locations are found as follows : resolvedPrimaryLocation/../secondaryLocation/resolvedDefFileName
			if secondaryDefaultDefFileDir:
				primaryFileCheck = raptor_utilities.resolveSymbianPath(self.__defFileRoot, resolvedDefFile, 'DEFFILE', "", str(aBuildPlatform['EPOCROOT']))
			
				if not os.path.exists(primaryFileCheck):
					isSecondaryDefaultDefFile = True
					resolvedDefFile = "{0}/../{1}/{2}".format(os.path.dirname(resolvedDefFile), secondaryDefaultDefFileDir, os.path.basename(resolvedDefFile))

			resolvedDefFile = raptor_utilities.resolveSymbianPath(self.__defFileRoot, resolvedDefFile, 'DEFFILE', "", str(aBuildPlatform['EPOCROOT']))

		return (resolvedDefFile, isSecondaryDefaultDefFile)


def CheckedGet(self, key, default = None):
	"""extract a value from an self and raise an exception if None.

	An optional default can be set to replace a None value.

	This function belongs in the Evaluator class logically. But
	Evaluator doesn't know how to raise a Metadata error. Since
	being able to raise a metadata error is the whole point of
	the method, it makes sense to adapt the Evaluator class from
	raptor_meta for the use of everything inside raptor_meta.

	... so it will be added to the Evaluator class.
	"""

	value = self.Get(key)
	if value == None:
		if default == None:
			raise MetaDataError("configuration " + self.buildUnit.name +
							    " has no variable " + key)
		else:
			return default
	return value

raptor_data.Evaluator.CheckedGet = CheckedGet 


class MetaReader(object):
	"""Entry point class for Symbian metadata processing.

	Provides a means of integrating "traditional" Symbian metadata processing
	with the new Raptor build system."""

	filesplit_re = re.compile(r"^(?P<name>.*)\.(?P<ext>[^\.]*)$")

	def __init__(self, aRaptor, configsToBuild):
		self.__Raptor = aRaptor
		self.BuildPlatforms = []
		self.ExportPlatforms = []

		# Get the version of CPP that we are using
		metadata = self.__Raptor.cache.FindNamedVariant("meta")
		evaluator = self.__Raptor.GetEvaluator(None, raptor_data.BuildUnit(metadata.name, [metadata]) )
		self.__gnucpp = evaluator.CheckedGet("GNUCPP")
		self.__defaultplatforms = evaluator.CheckedGet("DEFAULT_PLATFORMS")
		self.__basedefaultplatforms = evaluator.CheckedGet("BASE_DEFAULT_PLATFORMS")
		self.__baseuserdefaultplatforms = evaluator.CheckedGet("BASE_USER_DEFAULT_PLATFORMS")

		# Only read each variant.cfg once
		variantCfgs = {}

		# Group the list of configurations into "build platforms".
		# A build platform is a set of configurations which share
		# the same metadata. In other words, a set of configurations
		# for which the bld.inf and MMP files pre-process to exactly
		# the same text.
		platforms = {}

		# Exports are not "platform dependent" but they are configuration
		# dependent because different configs can have different EPOCROOT
		# and VARIANT_HRH values. Each "build platform" has one associated
		# "export platform" but several "build platforms" can be associated
		# with the same "export platform".
		exports = {}
		
		# We sort configurations by name here.  This is solely to deal with situations
		# where macros linked to builds end up being used in preprocessor conditionals
		# within bld.inf files that then wrap exports under PRJ_EXPORTS statements.
		# Having exports that are conditional on these macros isn't supported, but
		# as there are areas of the source base that make this assumption, and
		# fail if emulator macros are used instead of arm ones, we ensure that arm
		# configurations come first when multiple configurations are active, and so are
		# used first for determining exports.
		sortedConfigsToBuild = sorted(configsToBuild,key=lambda config: config.name)

		self.__Raptor.Debug("MetaReader: sortedConfigsToBuild:  %s", [b.name for b in sortedConfigsToBuild])
		for buildConfig in sortedConfigsToBuild:
			# get everything we need to know about the configuration
			evaluator = self.__Raptor.GetEvaluator(None, buildConfig)

			detail = {}
			detail['PLATFORM'] = evaluator.CheckedGet("TRADITIONAL_PLATFORM")
			epocroot = evaluator.CheckedGet("EPOCROOT")
			detail['EPOCROOT'] = generic_path.Path(epocroot)

			sbs_build_dir = evaluator.CheckedGet("SBS_BUILD_DIR")
			detail['SBS_BUILD_DIR'] = generic_path.Path(sbs_build_dir)
			flm_export_dir = evaluator.CheckedGet("FLM_EXPORT_DIR")
			detail['FLM_EXPORT_DIR'] = generic_path.Path(flm_export_dir)
			detail['CACHEID'] = flm_export_dir
			if raptor_utilities.getOSPlatform().startswith("win"):
				detail['PLATMACROS'] = evaluator.CheckedGet("PLATMACROS.WINDOWS")
			else:
				detail['PLATMACROS'] = evaluator.CheckedGet("PLATMACROS.LINUX")

			# Apply OS variant provided we are not ignoring this
			if not self.__Raptor.ignoreOsDetection:
				self.__Raptor.Debug("Automatic OS detection enabled.")
				self.ApplyOSVariant(buildConfig, epocroot)
			else: # We are ignore OS versions so no detection required, so no variant will be applied
				self.__Raptor.Debug("Automatic OS detection disabled.")

			# is this a feature variant config or an ordinary variant
			fvn = evaluator.Get("FEATUREVARIANTNAME")
			detail['ISFEATUREVARIANT'] = (fvn != None and fvn != '')

			# get the .hrh name from VARIANT_HRH if it is set, otherwise read
			# the name from the contents of the file named in VARIANT_CFG
			variantHdr = evaluator.Get("VARIANT_HRH")
			if variantHdr:
				variantHRH = generic_path.Path(variantHdr)
			else:
				variantCfg = evaluator.CheckedGet("VARIANT_CFG")
				variantCfg = generic_path.Path(variantCfg)
				if not variantCfg in variantCfgs:
					# get VARIANT_HRH from the variant.cfg file
					varCfg = getVariantCfgDetail(detail['EPOCROOT'], variantCfg)
					variantCfgs[variantCfg] = varCfg['VARIANT_HRH']
					# we expect to always build ABIv2
					if not 'ENABLE_ABIV2_MODE' in varCfg:
						self.__Raptor.Warn("missing flag ENABLE_ABIV2_MODE in %s file. ABIV1 builds are not supported.",
										   str(variantCfg))
				variantHRH = variantCfgs[variantCfg]

			detail['VARIANT_HRH'] = variantHRH
			self.__Raptor.Info("'%s' uses variant hrh file '%s'", buildConfig.name, variantHRH)
			detail['SYSTEMINCLUDE'] = evaluator.CheckedGet("SYSTEMINCLUDE")

			detail['TARGET_TYPES'] = evaluator.CheckedGet("TARGET_TYPES")

			# find all the interface names we need
			ifaceTypes = evaluator.CheckedGet("INTERFACE_TYPES")
			interfaces = ifaceTypes.split()

			for iface in interfaces:
				detail[iface] = evaluator.CheckedGet("INTERFACE." + iface)

			# not test code unless positively specified
			detail['TESTCODE'] = evaluator.CheckedGet("TESTCODE", "")

			# make a key that identifies this platform uniquely
			# - used to tell us whether we have done the pre-processing
			# we need already using another platform with compatible values.

			key = str(detail['VARIANT_HRH']) \
			 	+ str(detail['EPOCROOT']) \
		    	+ detail['SYSTEMINCLUDE'] \
		    	+ detail['PLATFORM'] \
		    	+ detail['PLATMACROS']

		    # Keep a short version of the key for use in filenames.
			uniq = hashlib.md5()
			uniq.update(key)

			detail['key'] = key
			detail['key_md5'] = "p_" + uniq.hexdigest()
			del uniq

			# compare this configuration to the ones we have already seen

			# Is this an unseen export platform?
			# concatenate all the values we care about in a fixed order
			# and use that as a signature for the exports.
			items = ['EPOCROOT', 'VARIANT_HRH', 'SYSTEMINCLUDE', 'TESTCODE', 'export']
			export = ""
			for i in  items:
				if i in detail:
					export += i + str(detail[i])

			if export in exports:
				# add this configuration to an existing export platform
				index = exports[export]
				self.ExportPlatforms[index]['configs'].append(buildConfig)
			else:
				# create a new export platform with this configuration
				exports[export] = len(self.ExportPlatforms)
				exp = copy.copy(detail)
				exp['PLATFORM'] = 'EXPORT'
				exp['configs']  = [buildConfig]
				self.ExportPlatforms.append(exp)

			# Is this an unseen build platform?
			# concatenate all the values we care about in a fixed order
			# and use that as a signature for the platform.
			items = ['PLATFORM', 'PLATMACROS', 'EPOCROOT', 'VARIANT_HRH', 'SYSTEMINCLUDE', 'TESTCODE']

			items.extend(interfaces)
			platform = ""
			for i in  items:
				if i in detail:
					platform += i + str(detail[i])

			if platform in platforms:
				# add this configuration to an existing build platform
				index = platforms[platform]
				self.BuildPlatforms[index]['configs'].append(buildConfig)
			else:
				# create a new build platform with this configuration
				platforms[platform] = len(self.BuildPlatforms)
				detail['configs'] = [buildConfig]
				self.BuildPlatforms.append(detail)

		# one platform is picked as the "default" for extracting things
		# that are supposedly platform independent (e.g. PRJ_PLATFORMS)
		self.defaultPlatform = self.ExportPlatforms[0]


	def ReadBldInfFiles(self, aComponentList, doexport, dobuild = True):
		"""Take a list of bld.inf files and return a list of build specs.

		The returned specification nodes will be suitable for all the build
		configurations under consideration (using Filter nodes where required).
		"""

		# we need a Filter node per export platform
		exportNodes = []
		for i,ep in enumerate(self.ExportPlatforms):
			filter = raptor_data.Filter(name = "export_" + str(i))

			# what configurations is this node active for?
			for config in ep['configs']:
				filter.AddConfigCondition(config.name)

			exportNodes.append(filter)

		# we need a Filter node per build platform
		platformNodes = []
		for i,bp in enumerate(self.BuildPlatforms):
			filter = raptor_data.Filter(name = "build_" + str(i))

			# what configurations is this node active for?
			for config in bp['configs']:
				filter.AddConfigCondition(config.name)

			# platform-wide data
			platformVar = raptor_data.Variant()
			platformVar.AddOperation(raptor_data.Set("PRODUCT_INCLUDE",
													 str(bp['VARIANT_HRH'])))

			filter.AddVariant(platformVar)
			platformNodes.append(filter)

		# check that each bld.inf exists and add a Specification node for it
		# to the nodes of the export and build platforms that it supports.
		for c in aComponentList:
			if c.bldinf_filename.isFile():
				self.__Raptor.Info("Processing %s", str(c.bldinf_filename))
				try:
					self.AddComponentNodes(c, exportNodes, platformNodes)

				except MetaDataError, e:
					self.__Raptor.Error(e.Text, bldinf=str(c.bldinf_filename))
					if not self.__Raptor.keepGoing:
						return []
			else:
				self.__Raptor.Error("build info file does not exist", bldinf=str(c.bldinf_filename))
				if not self.__Raptor.keepGoing:
					return []

		# now we have the top-level structure in place...
		#
		# <filter exports 1>
		#		<spec bld.inf 1 />
		#		<spec bld.inf 2 />
		#		<spec bld.inf N /> </filter>
		# <filter build 1>
		#		<spec bld.inf 1 />
		#		<spec bld.inf 2 />
		#		<spec bld.inf N /> </filter>
		# <filter build 2>
		#		<spec bld.inf 1 />
		#		<spec bld.inf 2 />
		#		<spec bld.inf N /> </filter>
		# <filter build 3>
		#		<spec bld.inf 1 />
		#		<spec bld.inf 2 />
		#		<spec bld.inf N /> </filter>
		#
		# assuming that every bld.inf builds for every platform and all
		# exports go to the same place. clearly, it is more likely that
		# some filters have less than N child nodes. in bigger builds there
		# will also be more than one export platform.

		# we now need to process the EXPORTS for all the bld.inf nodes
		# before we can do anything else (because raptor itself must do
		# some exports before the MMP files that include them can be
		# processed).
		if doexport:
			for i,p in enumerate(exportNodes):
				exportPlatform = self.ExportPlatforms[i]
				for s in p.GetChildSpecs():
					try:
						self.ProcessExports(s, exportPlatform)

					except MetaDataError, e:
						self.__Raptor.Error("%s",e.Text)
						if not self.__Raptor.keepGoing:
							return []
		else:
			self.__Raptor.Info("Not Processing Exports (--noexport enabled)")

		# this is a switch to return the function at this point if export
		# only option is specified in the run
		if dobuild is not True:
			self.__Raptor.Info("Processing Exports only")
			return[]

		# after exports are done we can look to see if there are any
		# new Interfaces which can be used for EXTENSIONS. Make sure
		# that we only load each cache once as some export platforms
		# may share a directory.
		doneID = {}
		for ep in self.ExportPlatforms:
			flmDir = ep["FLM_EXPORT_DIR"]
			cid = ep["CACHEID"]
			if flmDir.isDir() and not cid in doneID:
				self.__Raptor.cache.Load(flmDir, cid)
			doneID[cid] = True

		# finally we can process all the other parts of the bld.inf nodes.
		# Keep a list of the projects we were asked to build so that we can
		# tell at the end if there were any we didn't know about.
		self.projectList = list(self.__Raptor.projects)
		for i,p in enumerate(platformNodes):
			buildPlatform = self.BuildPlatforms[i]
			for s in p.GetChildSpecs():
				try:
					self.ProcessTEMs(s, buildPlatform)
					self.ProcessMMPs(s, buildPlatform)

				except MetaDataError, e:
					self.__Raptor.Error(e.Text)
					if not self.__Raptor.keepGoing:
						return []

		for badProj in self.projectList:
			self.__Raptor.Warn("Can't find project '%s' in any build info file", badProj)

		# everything is specified
		return exportNodes + platformNodes

	def ModuleName(self,aBldInfPath):
		"""Calculate the name of the ROM/emulator batch files that run the tests"""

		def LeftPortionOf(pth,sep):
			""" Internal function to return portion of str that is to the left of sep. 
			The split is case-insensitive."""
			length = len((pth.lower().split(sep.lower()))[0])
			return pth[0:length]
			
		modulePath = LeftPortionOf(LeftPortionOf(os.path.dirname(aBldInfPath), "group"), "ongoing")
		moduleName = os.path.basename(modulePath.strip("/"))
		
		# Ensure that ModuleName does not return blank, if the above calculation determines
		# that moduleName is blank
		if moduleName == "" or moduleName.endswith(":"):
			moduleName = "module"
		return moduleName


	def AddComponentNodes(self, component, exportNodes, platformNodes):	
		"""Add Specification nodes for a bld.inf to the appropriate platforms."""
		bldInfFile = BldInfFile(component.bldinf_filename, self.__gnucpp, component.depfiles, self.__Raptor)
		component.bldinf = bldInfFile 

		specName = getSpecName(component.bldinf_filename, fullPath=True)

		# exports are independent of build platform
		for i,ep in enumerate(self.ExportPlatforms):
			specNode = raptor_data.Specification(name = specName)

			# keep the BldInfFile object for later
			specNode.component = component

			# add some basic data in a component-wide variant
			var = raptor_data.Variant(name='component-wide')
			var.AddOperation(raptor_data.Set("COMPONENT_META", str(component.bldinf_filename)))
			var.AddOperation(raptor_data.Set("COMPONENT_NAME", component.componentname))
			var.AddOperation(raptor_data.Set("COMPONENT_LAYER", component.layername))
			specNode.AddVariant(var)

			# add this bld.inf Specification to the export platform
			exportNodes[i].AddChild(specNode)
			component.exportspecs.append(specNode)

		# get the relevant build platforms
		listedPlatforms = bldInfFile.getBuildPlatforms(self.defaultPlatform)
		platforms = getBuildableBldInfBuildPlatforms(listedPlatforms,
								self.__defaultplatforms,
								self.__basedefaultplatforms,
								self.__baseuserdefaultplatforms)


		outputDir = BldInfFile.outputPathFragment(component.bldinf_filename)

		# Calculate "module name"
		modulename = self.ModuleName(str(component.bldinf_filename))

		for i,bp in enumerate(self.BuildPlatforms):
			plat = bp['PLATFORM']
			if bp['PLATFORM'] in platforms:
				specNode = raptor_data.Specification(name = specName)

				# remember what component this spec node comes from for later
				specNode.component = component

				# add some basic data in a component-wide variant
				var = raptor_data.Variant(name='component-wide-settings-' + plat)
				var.AddOperation(raptor_data.Set("COMPONENT_META",str(component.bldinf_filename)))
				var.AddOperation(raptor_data.Set("COMPONENT_NAME", component.componentname))
				var.AddOperation(raptor_data.Set("COMPONENT_LAYER", component.layername))
				var.AddOperation(raptor_data.Set("MODULE", modulename))
				var.AddOperation(raptor_data.Append("OUTPUTPATHOFFSET", outputDir, '/'))
				var.AddOperation(raptor_data.Append("OUTPUTPATH", outputDir, '/'))
				var.AddOperation(raptor_data.Append("BLDINF_OUTPUTPATH",outputDir, '/'))

				var.AddOperation(raptor_data.Set("TEST_OPTION", component.bldinf.getRomTestType(bp)))
				specNode.AddVariant(var)

				# add this bld.inf Specification to the build platform
				platformNodes[i].AddChild(specNode)
				# also attach it into the component
				component.specs.append(specNode)

	def ProcessExports(self, componentNode, exportPlatform):
		"""Do the exports for a given platform and skeleton bld.inf node.

		This will actually perform exports as certain types of files (.mmh)
		are required to be in place before the rest of the bld.inf node
		(and parts of other bld.inf nodes) can be processed.

		[some MMP files #include exported .mmh files]
		"""
		if exportPlatform["TESTCODE"]:
			exports = componentNode.component.bldinf.getTestExports(exportPlatform)
		else:
			exports = componentNode.component.bldinf.getExports(exportPlatform)

		self.__Raptor.Debug("%i exports for %s",
							len(exports), str(componentNode.component.bldinf.filename))
		if exports:

			# each export is either a 'copy' or 'unzip'
			# maybe we should trap multiple exports to the same location here?
			epocroot = str(exportPlatform["EPOCROOT"])
			bldinf_filename = str(componentNode.component.bldinf.filename)
			exportwhatlog="<whatlog bldinf='%s' mmp='' config=''>\n" % bldinf_filename
			for export in exports:
				expSrc = export.getSource()
				expDstList = export.getDestination() # Might not be a list in all circumstances

				# make it a list if it isn't
				if not isinstance(expDstList, list):
					expDstList = [expDstList]

				fromFile = generic_path.Path(expSrc.replace("$(EPOCROOT)", epocroot))

				# For each destination in the destination list, add an export target, perform it if required.
				# This ensures that make knows the dependency situation but that the export is made
				# before any other part of the metadata requires it.  It also helps with the build
				# from clean situation where we can't use order only prerequisites.
				for expDst in expDstList:
					toFile = generic_path.Path(expDst.replace("$(EPOCROOT)", epocroot))
					try:
						if export.getAction() == "copy":
							# export the file
							exportwhatlog += self.CopyExport(fromFile, toFile, bldinf_filename)
						else:
							members = self.UnzipExport(fromFile, toFile,
									str(exportPlatform['SBS_BUILD_DIR']),
									bldinf_filename)
							
							exportwhatlog += ("<archive zipfile='" + str(fromFile) + "'>\n")
							if members != None:
								exportwhatlog += members
							exportwhatlog += "</archive>\n"
					except MetaDataError, e:
						if self.__Raptor.keepGoing:
							self.__Raptor.Error("%s",e.Text, bldinf=bldinf_filename)
						else:
							raise e
			exportwhatlog+="</whatlog>\n"
			self.__Raptor.PrintXML("%s",exportwhatlog)

	def CopyExport(self, _source, _destination, bldInfFile):
		"""Copy the source file to the destination file (create a directory
		   to copy into if it does not exist). Don't copy if the destination
		   file exists and has an equal or newer modification time."""
		source = generic_path.Path(str(_source).replace('%20',' '))
		destination = generic_path.Path(str(_destination).replace('%20',' '))
		dest_str = str(destination)
		source_str = str(source)

		exportwhatlog="<export destination='" + dest_str + "' source='" + \
				source_str + "'/>\n"

		try:


			destDir = destination.Dir()
			if not destDir.isDir():
				os.makedirs(str(destDir))
				shutil.copyfile(source_str, dest_str)
				return exportwhatlog

			sourceMTime = 0
			destMTime = 0
			sourceStat = 0
			try:
				sourceStat = os.stat(source_str)
				sourceMTime = sourceStat[stat.ST_MTIME]
				destMTime = os.stat(dest_str)[stat.ST_MTIME]
			except OSError, e:
				if sourceMTime == 0:
					message = "Source of export does not exist:  " + str(source)
					if not self.__Raptor.keepGoing:
						raise MetaDataError(message)
					else:
						self.__Raptor.Error(message, bldinf=bldInfFile)

			if destMTime == 0 or destMTime < sourceMTime:
				if os.path.exists(dest_str):
					os.chmod(dest_str,stat.S_IREAD | stat.S_IWRITE)
				shutil.copyfile(source_str, dest_str)

				# Ensure that the destination file remains executable if the source was also:
				os.chmod(dest_str,sourceStat[stat.ST_MODE] | stat.S_IREAD | stat.S_IWRITE | stat.S_IWGRP ) 
				self.__Raptor.Info("Copied %s to %s", source_str, dest_str)
			else:
				self.__Raptor.Info("Up-to-date: %s", dest_str)


		except Exception,e:
			message = "Could not export " + source_str + " to " + dest_str + " : " + str(e)
			if not self.__Raptor.keepGoing:
				raise MetaDataError(message)
			else:
				self.__Raptor.Error(message, bldinf=bldInfFile)

		return exportwhatlog


	def UnzipExport(self, _source, _destination, _sbs_build_dir, bldinf_filename):
		"""Unzip the source zipfile into the destination directory
		   but only if the markerfile does not already exist there
		   or it does exist but is older than the zipfile.
		   the markerfile is comprised of the name of the zipfile
		   with the ".zip" removed and ".unzipped" added.
		"""

		# Insert spaces into file if they are there
		source = str(_source).replace('%20',' ')
		destination = str(_destination).replace('%20',' ')
		sanitisedSource = raptor_utilities.sanitise(source)
		sanitisedDestination = raptor_utilities.sanitise(destination)

		destination = str(_destination).replace('%20',' ')
		exportwhatlog = ""


		try:
			if not _destination.isDir():
				os.makedirs(destination)

			# Form the directory to contain the unzipped marker files, and make the directory if require.
			markerfiledir = generic_path.Path(_sbs_build_dir)
			if not markerfiledir.isDir():
				os.makedirs(str(markerfiledir))

			# Form the marker file name and convert to Python string
			combinedPath = sanitisedSource + sanitisedDestination
			sanitisedPath = self.unzippedPathFragment(combinedPath)
			markerfilename = str(generic_path.Join(markerfiledir, sanitisedPath + ".unzipped"))

			# Don't unzip if the marker file is already there or more uptodate
			sourceMTime = 0
			destMTime = 0
			try:
				sourceMTime = os.stat(source)[stat.ST_MTIME]
				destMTime = os.stat(markerfilename)[stat.ST_MTIME]
			except OSError, e:
				if sourceMTime == 0:
					raise MetaDataError("Source zip for export does not exist:  " + source)
			if destMTime != 0 and destMTime >= sourceMTime:
				# This file has already been unzipped. Print members then return
				exportzip = zipfile.ZipFile(source, 'r')
				files = exportzip.namelist()
				files.sort()

				for file in files:
					if not file.endswith('/'):
						expfilename = str(generic_path.Join(destination, file))
						exportwhatlog += "<member>" + escape(expfilename) + "</member>\n"

				self.__Raptor.PrintXML("<clean bldinf='" + bldinf_filename + "' mmp='' config=''>\n")
				self.__Raptor.PrintXML("<zipmarker>" + markerfilename + "</zipmarker>\n")
				self.__Raptor.PrintXML("</clean>\n")

				return exportwhatlog

			exportzip = zipfile.ZipFile(source, 'r')
			files = exportzip.namelist()
			files.sort()
			filecount = 0
			for file in files:
				expfilename = str(generic_path.Join(destination, file))
				if file.endswith('/'):
					try:
						os.makedirs(expfilename)
					except OSError, e:
						pass # errors to do with "already exists" are not interesting.
				else:
					try:
						os.makedirs(os.path.split(expfilename)[0])
					except OSError, e:
						pass # errors to do with "already exists" are not interesting.

					try:
						if os.path.exists(expfilename):
							os.chmod(expfilename,stat.S_IREAD | stat.S_IWRITE)
						expfile = open(expfilename, 'wb')
						expfile.write(exportzip.read(file))
						expfile.close()
						
						# Resurrect any file execution permissions present in the archived version
						if (exportzip.getinfo(file).external_attr >> 16L) & 0100:
							os.chmod(expfilename, stat.S_IMODE(os.stat(expfilename).st_mode) | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)						
						
						# Each file keeps its modified time the same as what it was before unzipping
						accesstime = time.time()
						datetime = exportzip.getinfo(file).date_time
						timeTuple=(int(datetime[0]), int(datetime[1]), int(datetime[2]), int(datetime[3]), \
									int(datetime[4]), int(datetime[5]), int(0), int(0), int(0))
						modifiedtime = time.mktime(timeTuple)
						os.utime(expfilename,(accesstime, modifiedtime))

						filecount += 1
						exportwhatlog+="<member>" + escape(expfilename) + "</member>\n"
					except IOError, e:
						message = "Could not unzip %s to %s: file %s: %s" %(source, destination, expfilename, str(e))
						if not self.__Raptor.keepGoing:
							raise MetaDataError(message)
						else:
							self.__Raptor.Error(message, bldinf=bldinf_filename)

			markerfile = open(markerfilename, 'wb+')
			markerfile.close()
			self.__Raptor.PrintXML("<clean bldinf='" + bldinf_filename + "' mmp='' config=''>\n")
			self.__Raptor.PrintXML("<zipmarker>" + markerfilename +	"</zipmarker>\n")
			self.__Raptor.PrintXML("</clean>\n")

		except IOError, e:
			self.__Raptor.Warn("Problem while unzipping export %s to %s: %s",source,destination,str(e))

		self.__Raptor.Info("Unzipped %d files from %s to %s", filecount, source, destination)
		return exportwhatlog

	def ProcessTEMs(self, componentNode, buildPlatform):
		"""Add Template Extension Makefile nodes for a given platform
		   to a skeleton bld.inf node.

		This happens after exports have been handled.
		"""
		if buildPlatform["ISFEATUREVARIANT"]:
			return	# feature variation does not run extensions at all
		
		if buildPlatform["TESTCODE"]:
			extensions = componentNode.component.bldinf.getTestExtensions(buildPlatform)
		else:
			extensions = componentNode.component.bldinf.getExtensions(buildPlatform)

		self.__Raptor.Debug("%i template extension makefiles for %s",
							len(extensions), str(componentNode.component.bldinf.filename))

		for i,extension in enumerate(extensions):
			if self.__Raptor.projects:
				if not extension.nametag in self.__Raptor.projects:
					self.__Raptor.Debug("Skipping %s", extension.getMakefile())
					continue
				elif extension.nametag in self.projectList:
					self.projectList.remove(extension.nametag)

			extensionSpec = raptor_data.Specification("extension" + str(i))

			interface = buildPlatform["extension"]
			customInterface = False

			# is there an FLM replacement for this extension?
			if extension.interface:
				try:
					interface = self.__Raptor.cache.FindNamedInterface(extension.interface, buildPlatform["CACHEID"])
					customInterface = True
				except KeyError:
					# no, there isn't an FLM
					pass

			extensionSpec.SetInterface(interface)

			var = raptor_data.Variant()
			var.AddOperation(raptor_data.Set("EPOCBLD", "$(OUTPUTPATH)"))
			var.AddOperation(raptor_data.Set("PLATFORM", buildPlatform["PLATFORM"]))
			var.AddOperation(raptor_data.Set("PLATFORM_PATH", buildPlatform["PLATFORM"].lower()))
			var.AddOperation(raptor_data.Set("CFG", "$(VARIANTTYPE)"))
			var.AddOperation(raptor_data.Set("CFG_PATH", "$(VARIANTTYPE)"))
			var.AddOperation(raptor_data.Set("GENERATEDCPP", "$(OUTPUTPATH)"))
			var.AddOperation(raptor_data.Set("TEMPLATE_EXTENSION_MAKEFILE", extension.getMakefile()))
			var.AddOperation(raptor_data.Set("TEMCOUNT", str(i)))

			# Extension inputs are added to the build spec.
			# '$'s are escaped so that they are not expanded by Raptor or
			# by Make in the call to the FLM
			# The Extension makefiles are supposed to expand them themselves
			# Path separators need not be parameterised anymore
			# as bash is the standard shell
			standardVariables = extension.getStandardVariables()
			for standardVariable in standardVariables.keys():
				self.__Raptor.Debug("Set %s=%s", standardVariable, standardVariables[standardVariable])
				value = standardVariables[standardVariable].replace('$(', '$$$$(')
				value = value.replace('$/', '/').replace('$;', ':')
				var.AddOperation(raptor_data.Set(standardVariable, value))

			# . . . as with the standard variables but the names and number
			# of options are not known in advance so we add them to
			# a "structure" that is self-describing
			var.AddOperation(raptor_data.Set("O._MEMBERS", ""))
			options = extension.getOptions()
			for option in options:
				self.__Raptor.Debug("Set %s=%s", option, options[option])
				value = options[option].replace('$(EPOCROOT)', '$(EPOCROOT)/')
				value = value.replace('$(', '$$$$(')
				value = value.replace('$/', '/').replace('$;', ':')

				if customInterface:
					var.AddOperation(raptor_data.Set(option, value))
				else:
					var.AddOperation(raptor_data.Append("O._MEMBERS", option))
					var.AddOperation(raptor_data.Set("O." + option, value))

			extensionSpec.AddVariant(var)
			componentNode.AddChild(extensionSpec)


	def ProcessMMPs(self, componentNode, buildPlatform):
		"""Add project nodes for a given platform to a skeleton bld.inf node.

		This happens after exports have been handled.
		"""
		gnuList = []
		makefileList = []


		component = componentNode.component


		if buildPlatform["TESTCODE"]:
			MMPList = component.bldinf.getTestMMPList(buildPlatform)
		else:
			MMPList = component.bldinf.getMMPList(buildPlatform)

		bldInfFile = component.bldinf.filename

		for mmpFileEntry in MMPList['mmpFileList']:
			component.AddMMP(mmpFileEntry.filename) # Tell the component another mmp is specified (for this platform)

			projectname = mmpFileEntry.filename.File().lower()

			if self.__Raptor.projects:
				if not projectname in self.__Raptor.projects:
					self.__Raptor.Debug("Skipping %s", str(mmpFileEntry.filename))
					continue
				elif projectname in self.projectList:
					self.projectList.remove(projectname)

			foundmmpfile = (mmpFileEntry.filename).FindCaseless()

			if foundmmpfile == None:
				self.__Raptor.Error("Can't find mmp file '%s'", str(mmpFileEntry.filename), bldinf=str(bldInfFile))
				continue

			mmpFile = MMPFile(foundmmpfile,
								   self.__gnucpp,
								   component.bldinf,
								   component.depfiles,
								   log = self.__Raptor)

			mmpFilename = mmpFile.filename

			self.__Raptor.Info("Processing %s for platform %s",
							   str(mmpFilename),
							   " + ".join([x.name for x in buildPlatform["configs"]]))

			# Run the Parser
			# The backend supplies the actions
			content = mmpFile.getContent(buildPlatform)
			backend = MMPRaptorBackend(self.__Raptor, str(mmpFilename), str(bldInfFile))
			parser  = MMPParser(backend)
			parseresult = None
			try:
				parseresult = parser.mmp.parseString(content)
			except ParseException,e:
				self.__Raptor.Debug(e) # basically ignore parse exceptions

			if (not parseresult) or (parseresult[0] != 'MMP'):
				self.__Raptor.Error("The MMP Parser didn't recognise the mmp file '%s'",
					                str(mmpFileEntry.filename), 
					                bldinf=str(bldInfFile))
				self.__Raptor.Debug(content)
				self.__Raptor.Debug("The parse result was %s", parseresult)
			else:
				backend.finalise(buildPlatform)

			# if the parsed MMP file is fundamentally broken then report
			# the errors and stop processing this MMP node
			if not backend.validate():
				continue
			
			# feature variation only processes FEATUREVARIANT binaries
			if buildPlatform["ISFEATUREVARIANT"] and not backend.featureVariant:
				continue
			
			# now build the specification tree
			mmpSpec = raptor_data.Specification(generic_path.Path(getSpecName(mmpFilename)))
			var = backend.BuildVariant

			var.AddOperation(raptor_data.Set("PROJECT_META", str(mmpFilename)))

			# If it is a TESTMMPFILE section, the FLM needs to know about it
			if buildPlatform["TESTCODE"] and (mmpFileEntry.testoption in
					["manual", "auto"]):

				var.AddOperation(raptor_data.Set("TESTPATH",
						mmpFileEntry.testoption.lower() + ".bat"))

			# The output path for objects, stringtables and bitmaps specified by
			# this MMP.  Adding in the requested target extension prevents build
			# "fouling" in cases where there are several mmp targets which only differ
			# by the requested extension. e.g. elocl.01 and elocl.18
			var.AddOperation(raptor_data.Append("OUTPUTPATH","$(UNIQUETARGETPATH)",'/'))

			# If the bld.inf entry for this MMP had the BUILD_AS_ARM option then
			# tell the FLM.
			if mmpFileEntry.armoption:
				var.AddOperation(raptor_data.Set("ALWAYS_BUILD_AS_ARM","1"))

			# what interface builds this node?
			try:
				targettype = backend.getTargetType()
				validtargettypes = buildPlatform['TARGET_TYPES'].split()
			except KeyError:
				# Shouldn't get this since it should have been CheckedGetted already
				self.__Raptor.Error("TARGET_TYPES not defined in platform %s",
									buildPlatform['PLATFORM'])

			try:
				if not targettype in validtargettypes:
					self.__Raptor.Error("Unsupported target type '%s' in %s - should be one of %s",
										targettype,
										str(mmpFileEntry.filename),
										", ".join(validtargettypes),
										bldinf=str(bldInfFile))
				else:
					interfaceName = buildPlatform[targettype]
					mmpSpec.SetInterface(interfaceName)
			except KeyError:
				# Shouldn't get this far unless INTERFACE_TYPES doesn't contain TARGET_TYPES
				self.__Raptor.Error("%s interface not defined for %s (invalid configuration?)",
								    targettype,
									buildPlatform['PLATFORM'],
								    bldinf=str(bldInfFile))
				continue

			# Although not part of the MMP, some MMP-based build specs additionally require knowledge of their
			# container bld.inf exported headers
			for export in componentNode.component.bldinf.getExports(buildPlatform):
				destination = export.getDestination()
				if isinstance(destination, list):
					exportfile = str(destination[0])
				else:
					exportfile = str(destination)

				if re.search('\.h',exportfile,re.IGNORECASE):
					var.AddOperation(raptor_data.Append("EXPORTHEADERS", str(exportfile)))

			# now we have something worth adding to the component
			mmpSpec.AddVariant(var)
			componentNode.AddChild(mmpSpec)
			
			# if there are APPLY variants then add them to the mmpSpec too
			for applyVar in backend.ApplyVariants:
				try:
					mmpSpec.AddVariant(self.__Raptor.cache.FindNamedVariant(applyVar))
				except KeyError:
					self.__Raptor.Error("APPLY unknown variant '%s' in %s",
								        applyVar,
								        str(mmpFileEntry.filename),
								        bldinf=str(bldInfFile))

			# resources, stringtables and bitmaps are sub-nodes of this project
			# (do not add these for feature variant builds)
			
			if not buildPlatform["ISFEATUREVARIANT"]:
				# Buildspec for Resource files
				for i,rvar in enumerate(backend.ResourceVariants):
					resourceSpec = raptor_data.Specification('resource' + str(i))
					resourceSpec.SetInterface(buildPlatform['resource'])
					resourceSpec.AddVariant(rvar)
					mmpSpec.AddChild(resourceSpec)

				# Buildspec for String Tables
				for i,stvar in enumerate(backend.StringTableVariants):
					stringTableSpec = raptor_data.Specification('stringtable' + str(i))
					stringTableSpec.SetInterface(buildPlatform['stringtable'])
					stringTableSpec.AddVariant(stvar)
					mmpSpec.AddChild(stringTableSpec)

				# Buildspec for Bitmaps
				for i,bvar in enumerate(backend.BitmapVariants):
					bitmapSpec = raptor_data.Specification('bitmap' + str(i))
					bitmapSpec.SetInterface(buildPlatform['bitmap'])
					bitmapSpec.AddVariant(bvar)
					mmpSpec.AddChild(bitmapSpec)

		# feature variation does not run extensions at all
		# so return without considering .*MAKEFILE sections
		if buildPlatform["ISFEATUREVARIANT"]:
			return
			
		# Build spec for gnumakefile
		for g in MMPList['gnuList']:
			projectname = g.getMakefileName().lower()

			if self.__Raptor.projects:
				if not projectname in self.__Raptor.projects:
					self.__Raptor.Debug("Skipping %s", str(g.getMakefileName()))
					continue
				elif projectname in self.projectList:
					self.projectList.remove(projectname)

			self.__Raptor.Debug("%i gnumakefile extension makefiles for %s",
						len(gnuList), str(componentNode.component.bldinf.filename))
			var = raptor_data.Variant()
			gnuSpec = raptor_data.Specification("gnumakefile " + str(g.getMakefileName()))
			interface = buildPlatform["ext_makefile"]
			gnuSpec.SetInterface(interface)
			gnumakefilePath = raptor_utilities.resolveSymbianPath(str(bldInfFile), g.getMakefileName())
			var.AddOperation(raptor_data.Set("EPOCBLD", "$(OUTPUTPATH)"))
			var.AddOperation(raptor_data.Set("PLATFORM", buildPlatform["PLATFORM"]))
			var.AddOperation(raptor_data.Set("EXTMAKEFILENAME", g.getMakefileName()))
			var.AddOperation(raptor_data.Set("DIRECTORY",g.getMakeDirectory()))
			var.AddOperation(raptor_data.Set("CFG","$(VARIANTTYPE)"))
			standardVariables = g.getStandardVariables()
			for standardVariable in standardVariables.keys():
				self.__Raptor.Debug("Set %s=%s", standardVariable, standardVariables[standardVariable])
				value = standardVariables[standardVariable].replace('$(', '$$$$(')
				value = value.replace('$/', '/').replace('$;', ':')
				var.AddOperation(raptor_data.Set(standardVariable, value))
			gnuSpec.AddVariant(var)
			componentNode.AddChild(gnuSpec)

		# Build spec for makefile
		for m in MMPList['makefileList']:
			projectname = m.getMakefileName().lower()

			if self.__Raptor.projects:
				if not projectname in self.__Raptor.projects:
					self.__Raptor.Debug("Skipping %s", str(m.getMakefileName()))
					continue
				elif projectname in self.projectList:
					self.projectList.remove(projectname)

			self.__Raptor.Debug("%i makefile extension makefiles for %s",
						len(makefileList), str(componentNode.component.bldinf.filename))
			var = raptor_data.Variant()
			gnuSpec = raptor_data.Specification("makefile " + str(m.getMakefileName()))
			interface = buildPlatform["ext_makefile"]
			gnuSpec.SetInterface(interface)
			gnumakefilePath = raptor_utilities.resolveSymbianPath(str(bldInfFile), m.getMakefileName())
			var.AddOperation(raptor_data.Set("EPOCBLD", "$(OUTPUTPATH)"))
			var.AddOperation(raptor_data.Set("PLATFORM", buildPlatform["PLATFORM"]))
			var.AddOperation(raptor_data.Set("EXTMAKEFILENAME", m.getMakefileName()))
			var.AddOperation(raptor_data.Set("DIRECTORY",m.getMakeDirectory()))
			var.AddOperation(raptor_data.Set("CFG","$(VARIANTTYPE)"))
			var.AddOperation(raptor_data.Set("USENMAKE","1"))
			standardVariables = m.getStandardVariables()
			for standardVariable in standardVariables.keys():
				self.__Raptor.Debug("Set %s=%s", standardVariable, standardVariables[standardVariable])
				value = standardVariables[standardVariable].replace('$(', '$$$$(')
				value = value.replace('$/', '/').replace('$;', ':')
				var.AddOperation(raptor_data.Set(standardVariable, value))
			gnuSpec.AddVariant(var)
			componentNode.AddChild(gnuSpec)


	def ApplyOSVariant(self, aBuildUnit, aEpocroot):
		# Form path to kif.xml and path to buildinfo.txt
		kifXmlPath = generic_path.Join(aEpocroot, "epoc32", "data","kif.xml")
		buildInfoTxtPath = generic_path.Join(aEpocroot, "epoc32", "data","buildinfo.txt")

		# Start with osVersion being None. This variable is a string and does two things:
		# 1) is a representation of the OS version
		# 2) is potentially the name of a variant
		osVersion = None
		if kifXmlPath.isFile(): # kif.xml exists so try to read it
			osVersion = getOsVerFromKifXml(str(kifXmlPath))
			if osVersion != None:
				self.__Raptor.Info("OS version \"%s\" determined from file \"%s\"" % (osVersion, kifXmlPath))

		# OS version was not determined from the kif.xml, e.g. because it doesn't exist
		# or there was a problem parsing it. So, we fall over to using the buildinfo.txt
		if osVersion == None and buildInfoTxtPath.isFile():
			osVersion = getOsVerFromBuildInfoTxt(str(buildInfoTxtPath))
			if osVersion != None:
				self.__Raptor.Info("OS version \"%s\" determined from file \"%s\"" % (osVersion, buildInfoTxtPath))

		# If we determined a non-empty string for the OS Version, attempt to apply it
		if osVersion and osVersion in self.__Raptor.cache.variants:
			self.__Raptor.Info("applying the OS variant to the configuration \"%s\"." % aBuildUnit.name)
			aBuildUnit.variants.append(self.__Raptor.cache.variants[osVersion])
		else:
			self.__Raptor.Info("no OS variant for the configuration \"%s\"." % aBuildUnit.name)
			
	@classmethod		
	def unzippedPathFragment(self, sanitisedPath):
		fragment = hashlib.md5(sanitisedPath).hexdigest()[:16]
		return fragment


