FCL/sftools/dev/build: comparison sbsv2/raptor/python/raptor

equal deleted inserted replaced

-:86356a777616
+:cf0c187b284a
 		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."""
 		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)
 		try:
-			commandline = tool + " " + aArgs + " " + str(sourcefilename)
 			# the actual call differs between Windows and Unix
 			if raptor_utilities.getOSFileSystem() == "unix":
 				p = subprocess.Popen(commandline, \
 									 shell=True, bufsize=65535, \
 									 stdin=subprocess.PIPE, \
 							actualErr = True
 			if actualErr:
 				raise MetaDataError("Errors in %s" % str(sourcefilename))
 		except Exception,e:
-			raise MetaDataError("Preprocessor exception: %s" % str(e))
+			raise MetaDataError("Preprocessor exception: '%s' : in command : '%s'" % (str(e), commandline))
 		return 0	# all OK
 	def setMacros(self, aMacros):
 		self.__Macros = aMacros
 	Symbian metadata files are subject to preprocessing, primarily with macros based
 	on the selected build platform.  This class provides a generic means of wrapping
 	up the preprocessing of such files."""
-	def __init__(self, aFilename, gnucpp, aRootLocation=None, log=None):
+	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')
 			if raptor_utilities.getOSPlatform().startswith("win"):
 				metatarget = "$(PARSETARGET)"
 			else:
 				metatarget = "'$(PARSETARGET)'"
 			generateDepsOptions = "-MD -MF%s -MT%s" % (adepfilename, metatarget)
-			aBuildPlatform['METADEPS'].append((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")
 	Symbian metadata files are subject to preprocessing, primarily with macros based
 	on the selected build platform.  This class provides a generic means of wrapping
 	up the preprocessing of such files."""
-	def __init__(self, aFilename, gnucpp, bldinf, log=None):
+	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 bldinf file that this mmp comes from
+		@param bldinf		the bld.inf file this mmp was specified in
-		@param log 			A class with Debug(<string>), Info(<string>) and Error(<string>) methods
+		@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, str(bldinf.filename.Dir()), log)
+		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')
 class BldInfFile(MetaDataFile):
 	"""Representation of a Symbian bld.inf file"""
-	def __init__(self, aFilename, gnucpp, log=None):
+	def __init__(self, aFilename, gnucpp, depfiles, log=None):
-		MetaDataFile.__init__(self, aFilename, gnucpp, None, log)
+		MetaDataFile.__init__(self, aFilename, gnucpp, depfiles, None, log)
 		self.__Raptor = log
 		self.testManual = 0
 		self.testAuto = 0
 	# Generic
 	def __init__(self, aRaptor, aMmpfilename, aBldInfFilename):
 		super(MMPRaptorBackend,self).__init__()
 		self.platformblock = None
 		self.__Raptor = aRaptor
-		self.BuildVariant = raptor_data.Variant()
+		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.__sourcepath = raptor_utilities.resolveSymbianPath(self.__currentMmpFile, "")
 		self.__userinclude = ""
 		self.__systeminclude = ""
 		self.__bitmapSourcepath = self.__sourcepath
 		self.__current_resource = ""
-		self.__capabilities = []
 		self.__resourceFiles = []
 		self.__pageConflict = []
 		self.__debuggable = ""
+		self.__compressionKeyword = ""
 		self.sources = []
+		self.capabilities = []
 		self.__TARGET = ""
 		self.__TARGETEXT = ""
 		self.deffile = ""
 		self.__LINKAS = ""
 				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']:
+			if self.__compressionKeyword:
+				self.__Raptor.Warn("%s keyword in %s overrides earlier use of %s" % (varname, self.__currentMmpFile, self.__compressionKeyword))
+				self.BuildVariant.AddOperation(raptor_data.Set(self.__compressionKeyword,""))
+				self.__debug( "Set switch " + varname + " OFF")
+			self.BuildVariant.AddOperation(raptor_data.Set(varname,"1"))
+			self.__debug( "Set switch " + varname + " ON")
+			self.__compressionKeyword = varname
 		else:
 			self.__debug( "Set switch "+toks[0]+" ON")
 			self.BuildVariant.AddOperation(raptor_data.Set(prefix+varname, "1"))
 		return "OK"
 			self.__debug("Set "+varname+" to " + libName)
 			self.BuildVariant.AddOperation(raptor_data.Set(varname,"".join(libName)))
 		elif varname=='CAPABILITY':
 			for cap in toks[1]:
-				self.BuildVariant.AddOperation(raptor_data.Append(varname,cap," "))
 				self.__debug("Setting  "+toks[0]+": " + cap)
-				self.__capabilities.append(cap.lower())
+				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]))
 				# the major version number
 				major = int(version[0],10)
 				# add in the minor number
 				minor = 0
-				if len(version) >  1 and version[2] is not None:
+				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(varname+"HEX", self.__versionhex))
 				self.__debug("Set "+toks[0]+"  OPTION to " + toks[1])
 				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=='APPLY':
+			self.ApplyVariants.append(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':
 					# 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')
 	def doStartBitmap(self,s,loc,toks):
 		self.__currentLineNumber += 1
 		self.__debug("Start BITMAP "+toks[1])
-		self.__currentBitmapVariant = raptor_data.Variant(toks[1].replace('.','_'))
+		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.__debug("sourcepath: " + self.__sourcepath)
 		self.__debug("stringtable: " + toks[1])
 		self.__debug("adjusted stringtable source=" + source)
-		self.__currentStringTableVariant = raptor_data.Variant(uniqname)
+		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
 		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:
+		for capability in [c.lower() for c in self.capabilities]:
 			invert = 0
 			if capability.startswith('-'):
 				invert = 0xffffffff
 				capability = capability.lstrip('-')
 				resolvedDefFile = raptor_utilities.resolveSymbianPath(self.__defFileRoot, resolvedDefFile, 'DEFFILE', "", str(aBuildPlatform['EPOCROOT']))
 		return resolvedDefFile
+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."""
 		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 = self.CheckValue(evaluator, "GNUCPP")
+		self.__gnucpp = evaluator.CheckedGet("GNUCPP")
-		self.__defaultplatforms = self.CheckValue(evaluator, "DEFAULT_PLATFORMS")
+		self.__defaultplatforms = evaluator.CheckedGet("DEFAULT_PLATFORMS")
-		self.__basedefaultplatforms = self.CheckValue(evaluator, "BASE_DEFAULT_PLATFORMS")
+		self.__basedefaultplatforms = evaluator.CheckedGet("BASE_DEFAULT_PLATFORMS")
-		self.__baseuserdefaultplatforms = self.CheckValue(evaluator, "BASE_USER_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".
 		# 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 = {}
+		self.__Raptor.Debug("MetaReader: configsToBuild:  %s", [b.name for b in configsToBuild])
 		for buildConfig in configsToBuild:
 			# get everything we need to know about the configuration
 			evaluator = self.__Raptor.GetEvaluator(None, buildConfig)
 			detail = {}
-			detail['PLATFORM'] = self.CheckValue(evaluator, "TRADITIONAL_PLATFORM")
+			detail['PLATFORM'] = evaluator.CheckedGet("TRADITIONAL_PLATFORM")
-			epocroot = self.CheckValue(evaluator, "EPOCROOT")
+			epocroot = evaluator.CheckedGet("EPOCROOT")
 			detail['EPOCROOT'] = generic_path.Path(epocroot)
-			sbs_build_dir = self.CheckValue(evaluator, "SBS_BUILD_DIR")
+			sbs_build_dir = evaluator.CheckedGet("SBS_BUILD_DIR")
 			detail['SBS_BUILD_DIR'] = generic_path.Path(sbs_build_dir)
-			flm_export_dir = self.CheckValue(evaluator, "FLM_EXPORT_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'] = self.CheckValue(evaluator,"PLATMACROS.WINDOWS")
+				detail['PLATMACROS'] = evaluator.CheckedGet("PLATMACROS.WINDOWS")
 			else:
-				detail['PLATMACROS'] = self.CheckValue(evaluator,"PLATMACROS.LINUX")
+				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)
 				self.__Raptor.Debug("Automatic OS detection disabled.")
 			# is this a feature variant config or an ordinary variant
 			fv = evaluator.Get("FEATUREVARIANTNAME")
 			if fv:
-				variantHdr = self.CheckValue(evaluator, "VARIANT_HRH")
+				variantHdr = evaluator.CheckedGet("VARIANT_HRH")
 				variantHRH = generic_path.Path(variantHdr)
 				detail['ISFEATUREVARIANT'] = True
 			else:
-				variantCfg = self.CheckValue(evaluator, "VARIANT_CFG")
+				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']
 				variantHRH = variantCfgs[variantCfg]
 				detail['ISFEATUREVARIANT'] = False
 			detail['VARIANT_HRH'] = variantHRH
 			self.__Raptor.Info("'%s' uses variant hrh file '%s'", buildConfig.name, variantHRH)
-			detail['SYSTEMINCLUDE'] = self.CheckValue(evaluator, "SYSTEMINCLUDE")
+			detail['SYSTEMINCLUDE'] = evaluator.CheckedGet("SYSTEMINCLUDE")
-			detail['METADEPS'] = [] # Dependency targets for all metadata files in this platform
 			# find all the interface names we need
-			ifaceTypes = self.CheckValue(evaluator, "INTERFACE_TYPES")
+			ifaceTypes = evaluator.CheckedGet("INTERFACE_TYPES")
 			interfaces = ifaceTypes.split()
 			for iface in interfaces:
-				detail[iface] = self.CheckValue(evaluator, "INTERFACE." + iface)
+				detail[iface] = evaluator.CheckedGet("INTERFACE." + iface)
 			# not test code unless positively specified
-			detail['TESTCODE'] = self.CheckValue(evaluator, "TESTCODE", "")
+			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.
 		# 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 CheckValue(self, evaluator, key, default = None):
-		"""extract a value from an evaluator and raise an exception if None.
+	def ReadBldInfFiles(self, aComponentList, doexport, dobuild = True):
-		An optional default can be set to replace a None value."""
-		value = evaluator.Get(key)
-		if value == None:
-			if default == None:
-				raise MetaDataError("configuration " + evaluator.config.name +
-								    " has no variable " + key)
-			else:
-				return default
-		return value
-	def ReadBldInfFiles(self, aFileList, doExportOnly):
 		"""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("export_" + str(i))
+			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("build_" + str(i))
+			filter = raptor_data.Filter(name = "build_" + str(i))
 			# what configurations is this node active for?
 			for config in bp['configs']:
 				filter.AddConfigCondition(config.name)
 			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 bif in aFileList:
+		for c in aComponentList:
-			if bif.isFile():
+			if c.bldinf_filename.isFile():
-				self.__Raptor.Info("Processing %s", str(bif))
+				self.__Raptor.Info("Processing %s", str(c.bldinf_filename))
 				try:
-					self.AddComponentNodes(bif, exportNodes, platformNodes)
+					self.AddComponentNodes(c, exportNodes, platformNodes)
 				except MetaDataError, e:
-					self.__Raptor.Error(e.Text, bldinf=str(bif))
+					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(bif))
+				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...
 		#
 		# 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).
-		for i,p in enumerate(exportNodes):
+		if doexport:
-			exportPlatform = self.ExportPlatforms[i]
+			for i,p in enumerate(exportNodes):
-			for s in p.GetChildSpecs():
+				exportPlatform = self.ExportPlatforms[i]
-				try:
+				for s in p.GetChildSpecs():
-					self.ProcessExports(s, exportPlatform)
+					try:
+						self.ProcessExports(s, exportPlatform)
-				except MetaDataError, e:
-					self.__Raptor.Error("%s",e.Text)
+					except MetaDataError, e:
-					if not self.__Raptor.keepGoing:
+						self.__Raptor.Error("%s",e.Text)
-						return []
+						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 (self.__Raptor.doExportOnly):
+		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
 	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 partition is case-insentive."""
+			The split is case-insensitive."""
-			length = len((pth.lower().partition(sep.lower()))[0])
+			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("/"))
 		if moduleName == "" or moduleName.endswith(":"):
 			moduleName = "module"
 		return moduleName
-	def AddComponentNodes(self, buildFile, exportNodes, platformNodes):
+	def AddComponentNodes(self, component, exportNodes, platformNodes):
 		"""Add Specification nodes for a bld.inf to the appropriate platforms."""
-		bldInfFile = BldInfFile(buildFile, self.__gnucpp, self.__Raptor)
+		bldInfFile = BldInfFile(component.bldinf_filename, self.__gnucpp, component.depfiles, self.__Raptor)
+		component.bldinf = bldInfFile
-		specName = self.getSpecName(buildFile, fullPath=True)
+		specName = getSpecName(component.bldinf_filename, fullPath=True)
-		if isinstance(buildFile, raptor_xml.SystemModelComponent):
+		if isinstance(component.bldinf, raptor_xml.SystemModelComponent):
 			# this component came from a system_definition.xml
-			layer = buildFile.GetContainerName("layer")
+			layer = component.bldinf.GetContainerName("layer")
-			component = buildFile.GetContainerName("component")
+			componentName = component.bldinf.GetContainerName("component")
 		else:
 			# this is a plain old bld.inf file from the command-line
 			layer = ""
-			component = ""
+			componentName = ""
 		# exports are independent of build platform
 		for i,ep in enumerate(self.ExportPlatforms):
-			specNode = raptor_data.Specification(specName)
+			specNode = raptor_data.Specification(name = specName)
 			# keep the BldInfFile object for later
-			specNode.bldinf = bldInfFile
+			specNode.component = component
 			# add some basic data in a component-wide variant
-			var = raptor_data.Variant()
+			var = raptor_data.Variant(name='component-wide')
-			var.AddOperation(raptor_data.Set("COMPONENT_META", str(buildFile)))
+			var.AddOperation(raptor_data.Set("COMPONENT_META", str(component.bldinf_filename)))
-			var.AddOperation(raptor_data.Set("COMPONENT_NAME", component))
+			var.AddOperation(raptor_data.Set("COMPONENT_NAME", componentName))
 			var.AddOperation(raptor_data.Set("COMPONENT_LAYER", layer))
 			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.__defaultplatforms,
-													self.__basedefaultplatforms,
+								self.__basedefaultplatforms,
-													self.__baseuserdefaultplatforms)
+								self.__baseuserdefaultplatforms)
+		outputDir = BldInfFile.outputPathFragment(component.bldinf_filename)
-		outputDir = BldInfFile.outputPathFragment(buildFile)
 		# Calculate "module name"
-		modulename = self.ModuleName(str(buildFile))
+		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(specName)
+				specNode = raptor_data.Specification(name = specName)
-				# keep the BldInfFile object for later
+				# remember what component this spec node comes from for later
-				specNode.bldinf = bldInfFile
+				specNode.component = component
 				# add some basic data in a component-wide variant
-				var = raptor_data.Variant()
+				var = raptor_data.Variant(name='component-wide-settings-' + plat)
-				var.AddOperation(raptor_data.Set("COMPONENT_META",str(buildFile)))
+				var.AddOperation(raptor_data.Set("COMPONENT_META",str(component.bldinf_filename)))
-				var.AddOperation(raptor_data.Set("COMPONENT_NAME", component))
+				var.AddOperation(raptor_data.Set("COMPONENT_NAME", componentName))
 				var.AddOperation(raptor_data.Set("COMPONENT_LAYER", layer))
 				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", specNode.bldinf.getRomTestType(bp)))
+				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)
 		(and parts of other bld.inf nodes) can be processed.
 		[some MMP files #include exported .mmh files]
 		"""
 		if exportPlatform["TESTCODE"]:
-			exports = componentNode.bldinf.getTestExports(exportPlatform)
+			exports = componentNode.component.bldinf.getTestExports(exportPlatform)
 		else:
-			exports = componentNode.bldinf.getExports(exportPlatform)
+			exports = componentNode.component.bldinf.getExports(exportPlatform)
 		self.__Raptor.Debug("%i exports for %s",
-							len(exports), str(componentNode.bldinf.filename))
+							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.bldinf.filename)
+			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
 					try:
 						if export.getAction() == "copy":
 							# export the file
 							exportwhatlog += self.CopyExport(fromFile, toFile, bldinf_filename)
 						else:
-							# unzip the zip
 							exportwhatlog += ("<archive zipfile='" + str(fromFile) + "'>\n")
 							members = self.UnzipExport(fromFile, toFile,
 									str(exportPlatform['SBS_BUILD_DIR']),
 									bldinf_filename)
 							if members != None:
 						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))
 		"""
 		if buildPlatform["ISFEATUREVARIANT"]:
 			return	# feature variation does not run extensions at all
 		if buildPlatform["TESTCODE"]:
-			extensions = componentNode.bldinf.getTestExtensions(buildPlatform)
+			extensions = componentNode.component.bldinf.getTestExtensions(buildPlatform)
 		else:
-			extensions = componentNode.bldinf.getExtensions(buildPlatform)
+			extensions = componentNode.component.bldinf.getExtensions(buildPlatform)
 		self.__Raptor.Debug("%i template extension makefiles for %s",
-							len(extensions), str(componentNode.bldinf.filename))
+							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())
 		This happens after exports have been handled.
 		"""
 		gnuList = []
 		makefileList = []
+		component = componentNode.component
 		if buildPlatform["TESTCODE"]:
-			MMPList = componentNode.bldinf.getTestMMPList(buildPlatform)
+			MMPList = component.bldinf.getTestMMPList(buildPlatform)
 		else:
-			MMPList = componentNode.bldinf.getMMPList(buildPlatform)
+			MMPList = component.bldinf.getMMPList(buildPlatform)
-		bldInfFile = componentNode.bldinf.filename
+		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))
 				self.__Raptor.Error("Can't find mmp file '%s'", str(mmpFileEntry.filename), bldinf=str(bldInfFile))
 				continue
 			mmpFile = MMPFile(foundmmpfile,
 								   self.__gnucpp,
-								   bldinf = componentNode.bldinf,
+								   component.bldinf,
+								   component.depfiles,
 								   log = self.__Raptor)
 			mmpFilename = mmpFile.filename
 			self.__Raptor.Info("Processing %s for platform %s",
 			# feature variation only processes FEATUREVARIANT binaries
 			if buildPlatform["ISFEATUREVARIANT"] and not backend.featureVariant:
 				continue
 			# now build the specification tree
-			mmpSpec = raptor_data.Specification(self.getSpecName(mmpFilename))
+			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
 								    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.bldinf.getExports(buildPlatform):
+			for export in componentNode.component.bldinf.getExports(buildPlatform):
 				destination = export.getDestination()
 				if isinstance(destination, list):
 					exportfile = str(destination[0])
 				else:
 					exportfile = str(destination)
 					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"]:
 					continue
 				elif projectname in self.projectList:
 					self.projectList.remove(projectname)
 			self.__Raptor.Debug("%i gnumakefile extension makefiles for %s",
-						len(gnuList), str(componentNode.bldinf.filename))
+						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())
 					continue
 				elif projectname in self.projectList:
 					projectList.remove(projectname)
 			self.__Raptor.Debug("%i makefile extension makefiles for %s",
-						len(makefileList), str(componentNode.bldinf.filename))
+						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())
 				value = value.replace('$/', '/').replace('$;', ':')
 				var.AddOperation(raptor_data.Set(standardVariable, value))
 			gnuSpec.AddVariant(var)
 			componentNode.AddChild(gnuSpec)
-	def getSpecName(self, 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()
 	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")

changeset 44	cf0c187b284a
parent 2	86356a777616
parent 32	fdfc59a2ae7e
child 56	c02a2a09d864