25 import types

    25 import types

    26 import sys

    26 import sys

    27 import subprocess

    27 import subprocess

    28 from tempfile import gettempdir

    28 from tempfile import gettempdir

    29 from time import time, clock

    29 from time import time, clock

    32 

    37 

    33 # What host platforms we recognise

    38 # What host platforms we recognise

    34 # This allows us to tie some variants to one host platform and some to another

    39 # This allows us to tie some variants to one host platform and some to another

    35 class HostPlatform(object):

    40 class HostPlatform(object):

    36 	""" List the host platforms on which we can build.  Allow configuration

    41 	""" List the host platforms on which we can build.  Allow configuration

    66 # raptor_data module classes

    71 # raptor_data module classes

    67 

    72 

    68 class Model(object):

    73 class Model(object):

    69 	"Base class for data-model objects"

    74 	"Base class for data-model objects"

    70 

    75 

    71 	def __init__(self):

    78 	def __init__(self):

    73 		self.source = None	# XML file

    79 		self.source = None	# XML file

    75 		self.host = None

    80 		self.host = None

    76 		self.cacheID = ""	# default set of cached objects

    81 		self.cacheID = ""	# default set of cached objects

    81 

    84 

    82 

    85 

    83 	def SetSourceFile(self, filename):

    86 	def SetSourceFile(self, filename):

    84 		self.source = filename

    87 		self.source = filename

    85 

    88 

    89 

    92 

    90 

    93 

    91 	def AddChild(self, child):

    94 	def AddChild(self, child):

    92 		raise InvalidChildError()

    95 		raise InvalidChildError()

    93 

    96 

    98 

    97 

    99 	def Valid(self):

    98 	def Valid(self):

   100 		return False

    99 		return False

   101 

   100 

   102 	def IsApplicable(self):

   101 	def IsApplicable(self):

   137 			raise InvalidPropertyError()

   136 			raise InvalidPropertyError()

   138 

   137 

   139 	def Resolve(self):

   138 	def Resolve(self):

   140 		raise BadReferenceError()

   139 		raise BadReferenceError()

   141 

   140 

   144 		return [ cache.FindNamedVariant(m) for m in self.modifiers ]

   142 		return [ cache.FindNamedVariant(m) for m in self.modifiers ]

   145 

   143 

   146 	def Valid(self):

   144 	def Valid(self):

   147 		return self.ref

   145 		return self.ref

   148 

   146 

   152 	def __init__(self):

   150 	def __init__(self):

   153 		Model.__init__(self)	# base class constructor

   151 		Model.__init__(self)	# base class constructor

   154 		self.variants = []

   152 		self.variants = []

   155 

   153 

   156 

   154 

   166 

   157 

   167 

   158 

   168 	def AddVariant(self, variant):

   159 	def AddVariant(self, variant):

   169 		if type(variant) is types.StringTypes:

   160 		if type(variant) is types.StringTypes:

   171 

   162 

   172 

   163 

   173 		# Only add the variant if it's not in the list

   164 		# Only add the variant if it's not in the list

   174 		# already

   165 		# already

   175 		if not variant in self.variants:

   166 		if not variant in self.variants:

   176 			self.variants.append(variant)

   167 			self.variants.append(variant)

   177 

   168 

   179 		# resolve any VariantRef objects into Variant objects

   170 		# resolve any VariantRef objects into Variant objects

   180 		for i,var in enumerate(self.variants):

   172 		for i,var in enumerate(self.variants):

   181 			if isinstance(var, Reference):

   173 			if isinstance(var, Reference):

   182 				try:

   174 				try:

   184 

   176 

   185 				except BadReferenceError:

   177 				except BadReferenceError:

   187 

   182 

   188 		return self.variants

   183 		return self.variants

   189 

   184 

   190 

   185 

   191 class Interface(Model):

   186 class Interface(Model):

   197 		self.abstract = False

   192 		self.abstract = False

   198 		self.extends = None

   193 		self.extends = None

   199 		self.params = []

   194 		self.params = []

   200 		self.paramgroups = []

   195 		self.paramgroups = []

   201 

   196 

   208 		try:

   201 		try:

   210 		except KeyError:

   203 		except KeyError:

   211 			raise BadReferenceError("Cannot extend interface because it cannot be found: "+str(self.extends))

   204 			raise BadReferenceError("Cannot extend interface because it cannot be found: "+str(self.extends))

   212 

   205 

   214 		if self.extends != None:

   207 		if self.extends != None:

   216 

   209 

   217 			# what parameter names do we have already?

   210 			# what parameter names do we have already?

   218 			names = set([x.name for x in self.params])

   211 			names = set([x.name for x in self.params])

   219 

   212 

   220 			# pick up ones we don't have that are in our parent

   213 			# pick up ones we don't have that are in our parent

   221 			pp = []

   214 			pp = []

   223 				if not p.name in names:

   216 				if not p.name in names:

   224 					pp.append(p)

   217 					pp.append(p)

   225 

   218 

   226 			# list parent parameters first then ours

   219 			# list parent parameters first then ours

   227 			pp.extend(self.params)

   220 			pp.extend(self.params)

   228 			return pp

   221 			return pp

   229 

   222 

   230 		return self.params

   223 		return self.params

   231 

   224 

   233 		if self.extends != None:

   226 		if self.extends != None:

   235 

   228 

   236 			# what parameter names do we have already?

   229 			# what parameter names do we have already?

   237 			patterns = set([x.pattern for x in self.paramgroups])

   230 			patterns = set([x.pattern for x in self.paramgroups])

   238 

   231 

   239 			# pick up ones we don't have that are in our parent

   232 			# pick up ones we don't have that are in our parent

   241 				if not g.pattern in patterns:

   234 				if not g.pattern in patterns:

   242 					self.paramgroups.append(g)

   235 					self.paramgroups.append(g)

   243 

   236 

   244 		return self.paramgroups

   237 		return self.paramgroups

   245 

   238 

   246 

   239 

   248 		"absolute path to the FLM"

   241 		"absolute path to the FLM"

   249 

   242 

   250 		if self.flm == None:

   243 		if self.flm == None:

   251 			if self.extends != None:

   244 			if self.extends != None:

   255 			else:

   248 			else:

   256 				raise InvalidPropertyError()

   249 				raise InvalidPropertyError()

   257 

   250 

   258 		if not os.path.isabs(self.flm):

   251 		if not os.path.isabs(self.flm):

   259 			self.flm = os.path.join(os.path.dirname(self.source), self.flm)

   252 			self.flm = os.path.join(os.path.dirname(self.source), self.flm)

   293 		return (self.name != None)

   286 		return (self.name != None)

   294 

   287 

   295 

   288 

   296 class InterfaceRef(Reference):

   289 class InterfaceRef(Reference):

   297 

   290 

   302 		try:

   295 		try:

   304 		except KeyError:

   297 		except KeyError:

   305 			raise BadReferenceError()

   298 			raise BadReferenceError()

   306 

   299 

   307 

   300 

   308 class Specification(VariantContainer):

   301 class Specification(VariantContainer):

   314 		self.interface = None

   307 		self.interface = None

   315 		self.childSpecs = []

   308 		self.childSpecs = []

   316 		self.parentSpec = None

   309 		self.parentSpec = None

   317 

   310 

   318 

   311 

   324 		for c in self.childSpecs:

   315 		for c in self.childSpecs:

   337 

   319 

   338 

   320 

   339 	def SetProperty(self, name, value):

   321 	def SetProperty(self, name, value):

   340 		if name == "name":

   322 		if name == "name":

   341 			self.name = value

   323 			self.name = value

   342 		else:

   324 		else:

   343 			raise InvalidPropertyError()

   325 			raise InvalidPropertyError()

   344 

   326 

   345 

   327 

   347 		# configure all the children (some may be Filters or parents of)

   329 		# configure all the children (some may be Filters or parents of)

   348 		for spec in self.GetChildSpecs():

   330 		for spec in self.GetChildSpecs():

   350 

   332 

   351 

   333 

   352 	def HasInterface(self):

   334 	def HasInterface(self):

   353 		return self.interface != None

   335 		return self.interface != None

   354 

   336 

   356 	def SetInterface(self, interface):

   338 	def SetInterface(self, interface):

   357 		if isinstance(interface, Interface) \

   339 		if isinstance(interface, Interface) \

   358 		or isinstance(interface, InterfaceRef):

   340 		or isinstance(interface, InterfaceRef):

   359 			self.interface = interface

   341 			self.interface = interface

   360 		else:

   342 		else:

   365 		"""return the Interface (fetching from the cache if it was a ref)

   347 		"""return the Interface (fetching from the cache if it was a ref)

   366 		may return None"""

   348 		may return None"""

   367 

   349 

   368 		if self.interface == None \

   350 		if self.interface == None \

   369 		or isinstance(self.interface, Interface):

   351 		or isinstance(self.interface, Interface):

   370 			return self.interface

   352 			return self.interface

   371 

   353 

   372 		if isinstance(self.interface, InterfaceRef):

   354 		if isinstance(self.interface, InterfaceRef):

   373 			try:

   355 			try:

   375 				return self.interface

   357 				return self.interface

   376 

   358 

   377 			except BadReferenceError:

   359 			except BadReferenceError:

   381 

   361 

   382 	def AddChild(self, child):

   362 	def AddChild(self, child):

   383 		if isinstance(child, Specification):

   363 		if isinstance(child, Specification):

   384 			self.AddChildSpecification(child)

   364 			self.AddChildSpecification(child)

   385 		elif isinstance(child, Interface) \

   365 		elif isinstance(child, Interface) \

   407 

   387 

   408 	def Valid(self):

   388 	def Valid(self):

   409 		return True

   389 		return True

   410 

   390 

   411 

   391 

   413 		"""Returns all variants contained in this node and in its ancestors.

   393 		"""Returns all variants contained in this node and in its ancestors.

   414 

   394 

   415 		The returned value is a list, the structure of which is [variants-in-parent,

   395 		The returned value is a list, the structure of which is [variants-in-parent,

   416 		variants-in-self].

   396 		variants-in-self].

   417 

   397 

   418 		Note that the function recurses through parent *Specifications*, not through

   398 		Note that the function recurses through parent *Specifications*, not through

   419 		the variants themselves.

   399 		the variants themselves.

   420 		"""

   400 		"""

   421 		if self.parentSpec:

   401 		if self.parentSpec:

   423 		else:

   403 		else:

   424 			variants = []

   404 			variants = []

   425 

   405 

   427 

   407 

   428 		return variants

   408 		return variants

   429 

   409 

   430 

   410 

   431 class Filter(Specification):

   411 class Filter(Specification):

   436 	when the Configure method is called after setting up a Condition.

   416 	when the Configure method is called after setting up a Condition.

   437 

   417 

   438 	If several Conditions are set, the test is an OR of all of them."""

   418 	If several Conditions are set, the test is an OR of all of them."""

   439 

   419 

   440 	def __init__(self, name = ""):

   420 	def __init__(self, name = ""):

   443 		self.isTrue = True

   423 		self.isTrue = True

   444 		self.configNames = set()            #

   424 		self.configNames = set()            #

   445 		self.variableNames = set()          # TO DO: Condition class

   425 		self.variableNames = set()          # TO DO: Condition class

   446 		self.variableValues = {}            #

   426 		self.variableValues = {}            #

   447 

   427 

   457 

   436 

   458 

   437 

   459 	def SetConfigCondition(self, configName):

   438 	def SetConfigCondition(self, configName):

   460 		self.configNames = set([configName])

   439 		self.configNames = set([configName])

   461 

   440 

   476 			self.variableValues[variableName] = set(variableValues)

   455 			self.variableValues[variableName] = set(variableValues)

   477 		else:

   456 		else:

   478 			self.variableValues[variableName] = set([variableValues])

   457 			self.variableValues[variableName] = set([variableValues])

   479 

   458 

   480 

   459 

   482 		self.isTrue = False

   461 		self.isTrue = False

   483 

   462 

   484 		if buildUnit.name in self.configNames:

   463 		if buildUnit.name in self.configNames:

   485 			self.isTrue = True

   464 			self.isTrue = True

   486 		elif self.variableNames:

   465 		elif self.variableNames:

   488 

   468 

   489 			for variableName in self.variableNames:

   469 			for variableName in self.variableNames:

   490 				variableValue = evaluator.Get(variableName)

   470 				variableValue = evaluator.Get(variableName)

   491 

   471 

   492 				if variableValue in self.variableValues[variableName]:

   472 				if variableValue in self.variableValues[variableName]:

   493 					self.isTrue = True

   473 					self.isTrue = True

   494 					break

   474 					break

   495 

   475 

   496 		# configure all the children too

   476 		# configure all the children too

   497 		for spec in self.GetChildSpecs():

   477 		for spec in self.GetChildSpecs():

   506 

   479 

   507 

   480 

   508 	def HasInterface(self):

   481 	def HasInterface(self):

   509 		if self.isTrue:

   482 		if self.isTrue:

   510 			return Specification.HasInterface(self)

   483 			return Specification.HasInterface(self)

   511 		else:

   484 		else:

   512 			return self.Else.HasInterface()

   485 			return self.Else.HasInterface()

   513 

   486 

   514 

   487 

   516 		if self.isTrue:

   489 		if self.isTrue:

   523 		if self.isTrue:

   496 		if self.isTrue:

   527 

   500 

   528 

   501 

   529 	def SetParentSpec(self, parent):

   502 	def SetParentSpec(self, parent):

   530 		# base class method

   503 		# base class method

   531 		Specification.SetParentSpec(self, parent)

   504 		Specification.SetParentSpec(self, parent)

   589 		return (self.pattern != None and self.patternre != None)

   562 		return (self.pattern != None and self.patternre != None)

   590 

   563 

   591 

   564 

   592 class Operation(Model):

   565 class Operation(Model):

   593 	"Base class for variant operations"

   566 	"Base class for variant operations"

   594 	def __init__(self):

   568 	def __init__(self):

   595 		Model.__init__(self)	# base class constructor

   569 		Model.__init__(self)	# base class constructor

   596 		self.type = None

   570 		self.type = None

   597 

   571 

   599 	def Apply(self, oldValue):

   572 	def Apply(self, oldValue):

   600 		pass

   573 		pass

   601 

   574 

   602 

   575 

   603 class Append(Operation):

   576 class Append(Operation):

   606 	def __init__(self, name = None, value = None, separator = " "):

   578 	def __init__(self, name = None, value = None, separator = " "):

   607 		Operation.__init__(self)	# base class constructor

   579 		Operation.__init__(self)	# base class constructor

   608 		self.name = name

   580 		self.name = name

   609 		self.value = value

   581 		self.value = value

   610 		self.separator = separator

   582 		self.separator = separator

   611 

   583 

   612 

   584 

   614 		attributes = "name='" + self.name + "' value='" + self.value + "' separator='" + self.separator + "'"

   586 		attributes = "name='" + self.name + "' value='" + self.value + "' separator='" + self.separator + "'"

   616 

   588 

   617 

   589 

   618 	def Apply(self, oldValue):

   590 	def Apply(self, oldValue):

   619 		if len(oldValue) > 0:

   591 		if len(oldValue) > 0:

   620 			if len(self.value) > 0:

   592 			if len(self.value) > 0:

   639 	def Valid(self):

   611 	def Valid(self):

   640 		return (self.name != None and self.value != None)

   612 		return (self.name != None and self.value != None)

   641 

   613 

   642 

   614 

   643 class Prepend(Operation):

   615 class Prepend(Operation):

   644 	def __init__(self, name = None, value = None, separator = " "):

   617 	def __init__(self, name = None, value = None, separator = " "):

   645 		Operation.__init__(self)	# base class constructor

   618 		Operation.__init__(self)	# base class constructor

   646 		self.name = name

   619 		self.name = name

   647 		self.value = value

   620 		self.value = value

   648 		self.separator = separator

   621 		self.separator = separator

   649 

   622 

   650 

   623 

   652 		attributes = "name='" + self.name + "' value='" + self.value + "' separator='" + self.separator + "'"

   625 		attributes = "name='" + self.name + "' value='" + self.value + "' separator='" + self.separator + "'"

   654 

   627 

   655 

   628 

   656 	def Apply(self, oldValue):

   629 	def Apply(self, oldValue):

   657 		if len(oldValue) > 0:

   630 		if len(oldValue) > 0:

   658 			if len(self.value) > 0:

   631 			if len(self.value) > 0:

   677 	def Valid(self):

   650 	def Valid(self):

   678 		return (self.name != None and self.value != None)

   651 		return (self.name != None and self.value != None)

   679 

   652 

   680 

   653 

   681 class Set(Operation):

   654 class Set(Operation):

   682 	"""implementation of <set> operation"""

   656 	"""implementation of <set> operation"""

   684 

   657 

   685 	def __init__(self, name = None, value = "", type = ""):

   658 	def __init__(self, name = None, value = "", type = ""):

   686 		Operation.__init__(self)	# base class constructor

   659 		Operation.__init__(self)	# base class constructor

   687 		self.name = name

   660 		self.name = name

   688 		self.value = value

   661 		self.value = value

   689 		self.type = type

   662 		self.type = type

   690 		self.versionCommand = ""

   663 		self.versionCommand = ""

   691 		self.versionResult = ""

   664 		self.versionResult = ""

   692 

   665 

   693 

   666 

   695 		attributes = "name='" + self.name + "' value='" + self.value + "' type='" + self.type + "'"

   668 		attributes = "name='" + self.name + "' value='" + self.value + "' type='" + self.type + "'"

   696 		if type == "tool":

   669 		if type == "tool":

   697 			attributes += " versionCommand='" + self.versionCommand + "' versionResult='" + self.versionResult

   670 			attributes += " versionCommand='" + self.versionCommand + "' versionResult='" + self.versionResult

   698 

   671 

   700 

   673 

   701 

   674 

   702 	def Apply(self, oldValue):

   675 	def Apply(self, oldValue):

   703 		return self.value

   676 		return self.value

   704 

   677 

   722 

   695 

   723 

   696 

   724 	def Valid(self):

   697 	def Valid(self):

   725 		return (self.name != None and self.value != None)

   698 		return (self.name != None and self.value != None)

   726 

   699 

   727 

   702 

   728 class Env(Set):

   703 class Env(Set):

   729 	"""implementation of <env> operator"""

   704 	"""implementation of <env> operator"""

   730 

   705 

   731 	def __init__(self, name = None, default = None, type = ""):

   706 	def __init__(self, name = None, default = None, type = ""):

   732 		Set.__init__(self, name, "", type)	# base class constructor

   707 		Set.__init__(self, name, "", type)	# base class constructor

   733 		self.default = default

   708 		self.default = default

   734 

   709 

   735 

   710 

   737 		attributes = "name='" + self.name + "' type='" + self.type + "'"

   712 		attributes = "name='" + self.name + "' type='" + self.type + "'"

   738 		if default != None:

   713 		if default != None:

   739 			attributes += " default='" + self.default + "'"

   714 			attributes += " default='" + self.default + "'"

   740 

   715 

   741 		if type == "tool":

   716 		if type == "tool":

   742 			attributes += " versionCommand='" + self.versionCommand + "' versionResult='" + self.versionResult + "'"

   717 			attributes += " versionCommand='" + self.versionCommand + "' versionResult='" + self.versionResult + "'"

   743 

   718 

   745 

   720 

   746 

   721 

   747 	def Apply(self, oldValue):

   722 	def Apply(self, oldValue):

   748 		try:

   723 		try:

   749 			value = os.environ[self.name]

   724 			value = os.environ[self.name]

   753 			if value and (self.type == "path" or self.type == "tool"):

   728 			if value and (self.type == "path" or self.type == "tool"):

   754 				try:

   729 				try:

   755 					path = generic_path.Path(value)

   730 					path = generic_path.Path(value)

   756 					value = str(path.Absolute())

   731 					value = str(path.Absolute())

   757 				except ValueError,e:

   732 				except ValueError,e:

   760 		except KeyError:

   734 		except KeyError:

   761 			if self.default != None:

   735 			if self.default != None:

   762 				value = self.default

   736 				value = self.default

   763 			else:

   737 			else:

   766 

   739 

   767 		return value

   740 		return value

   768 

   741 

   769 

   742 

   770 	def SetProperty(self, name, value):

   743 	def SetProperty(self, name, value):

   789 

   762 

   790 		# Cache for the variant operations implied by this BuildUnit.

   763 		# Cache for the variant operations implied by this BuildUnit.

   791 		self.operations = []

   764 		self.operations = []

   792 		self.variantKey = ""

   765 		self.variantKey = ""

   793 

   766 

   795 		"""Return all operations related to this BuildUnit.

   768 		"""Return all operations related to this BuildUnit.

   796 		

   769 		

   797 		The result is cached, and so will only be computed once per BuildUnit.

   770 		The result is cached, and so will only be computed once per BuildUnit.

   798 		"""

   771 		"""

   799 		key = '.'.join([x.name for x in self.variants])

   772 		key = '.'.join([x.name for x in self.variants])

   800 		if self.variantKey != key:

   773 		if self.variantKey != key:

   801 			self.variantKey = key

   774 			self.variantKey = key

   802 			for v in self.variants:

   775 			for v in self.variants:

   804 

   777 

   805 		return self.operations

   778 		return self.operations

   806 

   779 

   807 class Config(object):

   780 class Config(object):

   808 	"""Abstract type representing an argument to the '-c' option.

   781 	"""Abstract type representing an argument to the '-c' option.

   818 		self.modifiers.append(variant)

   791 		self.modifiers.append(variant)

   819 

   792 

   820 	def ClearModifiers(self):

   793 	def ClearModifiers(self):

   821 		self.modifiers = []

   794 		self.modifiers = []

   822 

   795 

   824 		"""Returns a list of BuildUnits.

   797 		"""Returns a list of BuildUnits.

   825 

   798 

   826 		This function must be overridden by derived classes.

   799 		This function must be overridden by derived classes.

   827 		"""

   800 		"""

   828 		raise NotImplementedError()

   801 		raise NotImplementedError()

   829 

   802 

   830 

   803 

   831 class Variant(Model, Config):

   804 class Variant(Model, Config):

   832 

   807 

   833 	def __init__(self, name = ""):

   808 	def __init__(self, name = ""):

   834 		Model.__init__(self)

   809 		Model.__init__(self)

   835 		Config.__init__(self)

   810 		Config.__init__(self)

   836 		self.name = name

   811 		self.name = name

   866 			raise InvalidChildError()

   841 			raise InvalidChildError()

   867 

   842 

   868 	def Valid(self):

   843 	def Valid(self):

   869 		return self.name

   844 		return self.name

   870 

   845 

   881 	def AddOperation(self, op):

   846 	def AddOperation(self, op):

   882 		self.ops.append(op)

   847 		self.ops.append(op)

   883 

   848 

   885 		"""Returns a list of all operations in this variant.

   850 		"""Returns a list of all operations in this variant.

   886 

   851 

   887 		The list elements are themselves lists; the overall structure of the

   852 		The list elements are themselves lists; the overall structure of the

   888 		returned value is:

   853 		returned value is:

   889 

   854 

   890 		[ [ops-from-parent],[ops-from-varRefs], [ops-in-self] ]

   855 		[ [ops-from-parent],[ops-from-varRefs], [ops-in-self] ]

   891 		"""

   856 		"""

   892 

   857 

   893 		if not self.allOperations:

   858 		if not self.allOperations:

   894 			if self.extends:

   859 			if self.extends:

   897 			for r in self.variantRefs:

   862 			for r in self.variantRefs:

   900 			self.allOperations.append(self.ops)

   865 			self.allOperations.append(self.ops)

   901 

   866 

   902 		return self.allOperations

   867 		return self.allOperations

   903 

   868 

   905 

   870 

   906 		name = self.name

   871 		name = self.name

   907 		vars = [self]

   872 		vars = [self]

   908 

   873 

   909 		for m in self.modifiers:

   874 		for m in self.modifiers:

   910 			name = name + "." + m.name

   875 			name = name + "." + m.name

   911 			vars.append(m)

   876 			vars.append(m)

   918 		for op in self.ops:

   881 		for op in self.ops:

   924 class VariantRef(Reference):

   887 class VariantRef(Reference):

   925 

   888 

   926 	def __init__(self, ref=None):

   889 	def __init__(self, ref=None):

   933 		try:

   896 		try:

   936 			raise BadReferenceError(self.ref)

   899 			raise BadReferenceError(self.ref)

   937 

   900 

   938 

   903 

   939 class Alias(Model, Config):

   904 class Alias(Model, Config):

   940 

   905 

   941 	def __init__(self, name=""):

   906 	def __init__(self, name=""):

   942 		Model.__init__(self)

   907 		Model.__init__(self)

   944 		self.name = name

   909 		self.name = name

   945 		self.meaning = ""

   910 		self.meaning = ""

   946 		self.varRefs = []

   911 		self.varRefs = []

   947 		self.variants = []

   912 		self.variants = []

   948 

   913 

   951 

   916 

   952 	def SetProperty(self, key, val):

   917 	def SetProperty(self, key, val):

   953 		if key == "name":

   918 		if key == "name":

   954 			self.name = val

   919 			self.name = val

   955 		elif key == "meaning":

   920 		elif key == "meaning":

   956 			self.meaning = val

   921 			self.meaning = val

   957 

   922 

   958 			for u in val.split("."):

   923 			for u in val.split("."):

   960 		else:

   925 		else:

   961 			raise InvalidPropertyError()

   926 			raise InvalidPropertyError()

   967 

   927 

   968 	def Valid(self):

   928 	def Valid(self):

   969 		return self.name and self.meaning

   929 		return self.name and self.meaning

   970 

   930 

   972 		if not self.variants:

   932 		if not self.variants:

   973 			for r in self.varRefs:

   934 			for r in self.varRefs:

   974 				try:

   935 				try:

   976 				except BadReferenceError:

   937 				except BadReferenceError:

   978 

   942 

   979 		name = self.name

   943 		name = self.name

   980 

   944 

   981 		for v in self.modifiers:

   945 		for v in self.modifiers:

   982 			name = name + "." + v.name

   946 			name = name + "." + v.name

   983 

   947 

   985 

   949 

   986 

   950 

   987 class AliasRef(Reference):

   951 class AliasRef(Reference):

   988 

   952 

   989 	def __init__(self, ref=None):

   953 	def __init__(self, ref=None):

   990 		Reference.__init__(self, ref)

   954 		Reference.__init__(self, ref)

   991 

   955 

   996 		try:

   960 		try:

   998 		except KeyError:

   962 		except KeyError:

   999 			raise BadReferenceError(self.ref)

   963 			raise BadReferenceError(self.ref)

  1000 

   964 

  1001 

   965 

  1002 class Group(Model, Config):

   966 class Group(Model, Config):

  1016 		if isinstance( child, (VariantRef,AliasRef,GroupRef) ):

   980 		if isinstance( child, (VariantRef,AliasRef,GroupRef) ):

  1017 			self.childRefs.append(child)

   981 			self.childRefs.append(child)

  1018 		else:

   982 		else:

  1019 			raise InvalidChildError()

   983 			raise InvalidChildError()

  1020 

   984 

  1026 	def Valid(self):

   985 	def Valid(self):

  1027 		return self.name and self.childRefs

   986 		return self.name and self.childRefs

  1028 

   987 

  1033 		for r in self.childRefs:

   990 		for r in self.childRefs:

  1040 		units = []

   996 		units = []

  1041 

   997 

  1042 		for r in self.childRefs:

   999 		for r in self.childRefs:

  1044 

  1001 

  1045 			try:

  1002 			try:

  1047 			except BadReferenceError:

  1004 			except BadReferenceError:

  1049 			else:

  1006 			else:

  1050 				obj.ClearModifiers()

  1007 				obj.ClearModifiers()

  1051 

  1008 

  1052 				for m in refMods + self.modifiers:

  1009 				for m in refMods + self.modifiers:

  1053 					obj.AddModifier(m)

  1010 					obj.AddModifier(m)

  1054 

  1011 

  1056 

  1016 

  1057 		return units

  1017 		return units

  1058 

  1018 

  1059 

  1019 

  1060 class GroupRef(Reference):

  1020 class GroupRef(Reference):

  1061 

  1021 

  1062 	def __init__(self, ref=None):

  1022 	def __init__(self, ref=None):

  1063 		Reference.__init__(self, ref)

  1023 		Reference.__init__(self, ref)

  1064 

  1024 

  1070 		try:

  1029 		try:

  1072 		except KeyError:

  1031 		except KeyError:

  1073 			raise BadReferenceError(self.ref)

  1032 			raise BadReferenceError(self.ref)

  1074 

  1033 

  1075 class Tool(object):

  1038 class Tool(object):

  1076 	"""Represents a tool that might be used by raptor e.g. a compiler"""

  1039 	"""Represents a tool that might be used by raptor e.g. a compiler"""

  1077 

  1045 

  1078 	# For use in dealing with tools that return non-ascii version strings.

  1046 	# For use in dealing with tools that return non-ascii version strings.

  1079 	nonascii = ""

  1047 	nonascii = ""

  1080 	identity_chartable = chr(0)

  1048 	identity_chartable = chr(0)

  1081 	for c in xrange(1,128):

  1049 	for c in xrange(1,128):

  1082 		identity_chartable += chr(c)

  1050 		identity_chartable += chr(c)

  1083 	for c in xrange(128,256):

  1051 	for c in xrange(128,256):

  1084 		nonascii += chr(c)

  1052 		nonascii += chr(c)

  1085 		identity_chartable += " "

  1053 		identity_chartable += " "

  1086 

  1054 

  1088 		self.name = name

  1056 		self.name = name

  1089 		self.command = command

  1057 		self.command = command

  1090 		self.versioncommand = versioncommand

  1058 		self.versioncommand = versioncommand

  1091 		self.versionresult = versionresult

  1059 		self.versionresult = versionresult

  1092 		self.id = id # what config this is from - used in debug messages

  1060 		self.id = id # what config this is from - used in debug messages

  1095 

  1063 

  1096 		# Assume the tool is unavailable or the wrong

  1064 		# Assume the tool is unavailable or the wrong

  1097 		# version until someone proves that it's OK

  1065 		# version until someone proves that it's OK

  1098 		self.valid = False

  1066 		self.valid = False

  1099 

  1067 

  1101 

  1068 

  1102 	def expand(self, toolset):

  1069 	def expand(self, toolset):

  1103 		self.versioncommand = toolset.ExpandAll(self.versioncommand)

  1070 		self.versioncommand = toolset.ExpandAll(self.versioncommand)

  1104 		self.versionresult  = toolset.ExpandAll(self.versionresult)

  1071 		self.versionresult  = toolset.ExpandAll(self.versionresult)

  1105 		self.command = toolset.ExpandAll(self.command)

  1072 		self.command = toolset.ExpandAll(self.command)

  1115 				# executable file (e.g. "armcc" rather than "python myscript.py") then get it's date. 

  1082 				# executable file (e.g. "armcc" rather than "python myscript.py") then get it's date. 

  1116 				# We can use the date later to see if our cache is valid. 

  1083 				# We can use the date later to see if our cache is valid. 

  1117 				# If it really is not a simple command then we won't be able to get a date and

  1084 				# If it really is not a simple command then we won't be able to get a date and

  1118 				# we won't be able to tell if it is altered or updated - too bad!

  1085 				# we won't be able to tell if it is altered or updated - too bad!

  1119 				testfile = generic_path.Where(self.command)

  1086 				testfile = generic_path.Where(self.command)

  1121 				if testfile is None:

  1088 				if testfile is None:

  1122 					raise Exception("Can't be found in path")

  1089 					raise Exception("Can't be found in path")

  1123 

  1090 

  1124 			if not os.path.isfile(testfile):

  1091 			if not os.path.isfile(testfile):

  1125 				raise Exception("tool %s appears to not be a file %s", self.command, testfile)

  1092 				raise Exception("tool %s appears to not be a file %s", self.command, testfile)

  1126 				

  1093 				

  1127 			testfile_stat = os.stat(testfile)

  1094 			testfile_stat = os.stat(testfile)

  1128 			self.date = testfile_stat.st_mtime

  1095 			self.date = testfile_stat.st_mtime

  1129 		except Exception,e:

  1096 		except Exception,e:

  1131 	

  1100 	

  1132 			

  1101 			

  1134 

  1103 

  1135 		self.vre = re.compile(self.versionresult)

  1104 		self.vre = re.compile(self.versionresult)

  1136 

  1105 

  1137 		try:

  1106 		try:

  1138 			self.log.Debug("Pre toolcheck: '%s' for version '%s'", self.name, self.versionresult)

  1107 			self.log.Debug("Pre toolcheck: '%s' for version '%s'", self.name, self.versionresult)

  1139 			p = subprocess.Popen(args=[shell, "-c", self.versioncommand], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

  1108 			p = subprocess.Popen(args=[shell, "-c", self.versioncommand], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

  1140 			versionoutput,err = p.communicate()

  1110 			versionoutput,err = p.communicate()

  1142 		except Exception,e:

  1111 		except Exception,e:

  1143 			versionoutput=None

  1112 			versionoutput=None

  1144 

  1113 

  1145 		# Some tools return version strings with unicode characters! 

  1114 		# Some tools return version strings with unicode characters! 

  1146 		# There is no good response other than a lot of decoding and encoding.

  1115 		# There is no good response other than a lot of decoding and encoding.

  1147 		# Simpler to ignore it:

  1116 		# Simpler to ignore it:

  1148 		versionoutput_a = versionoutput.translate(Tool.identity_chartable,"")

  1117 		versionoutput_a = versionoutput.translate(Tool.identity_chartable,"")

  1149 

  1118 

  1150 		if versionoutput_a and self.vre.search(versionoutput_a) != None:

  1119 		if versionoutput_a and self.vre.search(versionoutput_a) != None:

  1152 			self.valid = True

  1121 			self.valid = True

  1153 		else:

  1122 		else:

  1155 			self.valid = False

  1123 			self.valid = False

  1157 

  1125 

  1158 def envhash(irrelevant_vars):

  1126 def envhash(irrelevant_vars):

  1159 	"""Determine something unique about this environment to identify it.

  1127 	"""Determine something unique about this environment to identify it.

  1160 	must ignore variables that change without mattering to the caller

  1128 	must ignore variables that change without mattering to the caller

  1161 	e.g. perhaps PATH matters but PWD and PPID don't"""

  1129 	e.g. perhaps PATH matters but PWD and PPID don't"""

  1173 	toolset.check() is called for each config but the cache is kept across calls to

  1141 	toolset.check() is called for each config but the cache is kept across calls to

  1174 	catch the use of one tool in many configs.

  1142 	catch the use of one tool in many configs.

  1175 	write() is used to flush the cache to disc.

  1143 	write() is used to flush the cache to disc.

  1176 	"""

  1144 	"""

  1177 	# The raptor shell - this is not mutable.

  1145 	# The raptor shell - this is not mutable.

  1180 	                            

  1151 	                            

  1188 

  1159 

  1189 

  1160 

  1190 	irrelevant_vars = ['PWD','OLDPWD','PID','PPID', 'SHLVL' ]

  1161 	irrelevant_vars = ['PWD','OLDPWD','PID','PPID', 'SHLVL' ]

  1191 

  1162 

  1192 

  1163 

  1253 									self.__toolcheckcache[toolhistory[0]] = ce

  1224 									self.__toolcheckcache[toolhistory[0]] = ce

  1254 								log.Info("Loaded toolcheck cache: %s\n", self.cachefilename)

  1225 								log.Info("Loaded toolcheck cache: %s\n", self.cachefilename)

  1255 							except Exception, e:

  1226 							except Exception, e:

  1256 								log.Info("Ignoring garbled toolcheck cache: %s (%s)\n", self.cachefilename, str(e))

  1227 								log.Info("Ignoring garbled toolcheck cache: %s (%s)\n", self.cachefilename, str(e))

  1257 								self.__toolcheckcache = {}

  1228 								self.__toolcheckcache = {}

  1259 									

  1229 									

  1260 						else:

  1230 						else:

  1261 							log.Info("Toolcheck cache %s ignored - environment changed\n", self.cachefilename)

  1231 							log.Info("Toolcheck cache %s ignored - environment changed\n", self.cachefilename)

  1262 					else:

  1232 					else:

  1263 						log.Info("Toolcheck cache not loaded = marker missing: %s %s\n", self.cachefilename, ToolSet.filemarker)

  1233 						log.Info("Toolcheck cache not loaded = marker missing: %s %s\n", self.cachefilename, ToolSet.filemarker)

  1314 						continue

  1284 						continue

  1315 

  1285 

  1316 

  1286 

  1317 			self.log.Debug("toolcheck done: %s -key: %s" % (tool.name, tool.key))

  1287 			self.log.Debug("toolcheck done: %s -key: %s" % (tool.name, tool.key))

  1318 

  1288 

  1320 				self.valid = False

  1292 				self.valid = False

  1321 

  1294 

  1322 			# Tool failures are cached just like successes - don't want to repeat them

  1295 			# Tool failures are cached just like successes - don't want to repeat them

  1323 			cache[tool.key] =  { "name" : tool.name, "valid" : tool.valid, "age" : 0 , "date" : tool.date }

  1296 			cache[tool.key] =  { "name" : tool.name, "valid" : tool.valid, "age" : 0 , "date" : tool.date }

  1324 

  1297 

  1325 

  1298 

  1354 				self.log.Info("Created/Updated toolcheck cache: %s\n", self.cachefilename)

  1327 				self.log.Info("Created/Updated toolcheck cache: %s\n", self.cachefilename)

  1355 			except Exception, e:

  1328 			except Exception, e:

  1356 				self.log.Info("Could not write toolcheck cache: %s", str(e))

  1329 				self.log.Info("Could not write toolcheck cache: %s", str(e))

  1357 		return self.valid

  1330 		return self.valid

  1358 

  1331 

  1359 

  1334 

  1360 class Evaluator(object):

  1335 class Evaluator(object):

  1361 	"""Determine the values of variables under different Configurations.

  1336 	"""Determine the values of variables under different Configurations.

  1362 	Either of specification and buildUnit may be None."""

  1337 	Either of specification and buildUnit may be None."""

  1363 

  1338 

  1364 

  1339 

  1365 	refRegex = re.compile("\$\((.+?)\)")

  1340 	refRegex = re.compile("\$\((.+?)\)")

  1366 

  1341 

  1369 		self.dict = {}

  1343 		self.dict = {}

  1370 		self.tools = []

  1344 		self.tools = []

  1371 		self.gathertools = gathertools

  1345 		self.gathertools = gathertools

  1372 

  1347 

  1373 		specName = "none"

  1348 		specName = "none"

  1374 		configName = "none"

  1349 		configName = "none"

  1375 

  1350 

  1376 		# A list of lists of operations.

  1351 		# A list of lists of operations.

  1377 		opsLists = []

  1352 		opsLists = []

  1378 

  1353 

  1379 		if buildUnit:

  1354 		if buildUnit:

  1381 

  1359 

  1382 		if specification:

  1360 		if specification:

  1385 

  1363 

  1386 		tools = {}

  1364 		tools = {}

  1387 

  1365 

  1388 		for opsList in opsLists:

  1367 		for opsList in opsLists:

  1389 			for op in opsList:

  1368 			for op in opsList:

  1390 				# applying an Operation to a non-existent variable

  1369 				# applying an Operation to a non-existent variable

  1391 				# is OK. We assume that it is just an empty string.

  1370 				# is OK. We assume that it is just an empty string.

  1392 				try:

  1371 				try:

  1393 					oldValue = self.dict[op.name]

  1372 					oldValue = self.dict[op.name]

  1394 				except KeyError:

  1373 				except KeyError:

  1395 					oldValue = ""

  1374 					oldValue = ""

  1396 

  1375 

  1398 				self.dict[op.name] = newValue

  1382 				self.dict[op.name] = newValue

  1399 			

  1383 			

  1400 				if self.gathertools:

  1384 				if self.gathertools:

  1401 					if op.type == "tool" and op.versionCommand and op.versionResult:

  1385 					if op.type == "tool" and op.versionCommand and op.versionResult:

  1404 

  1390 

  1405 		if self.gathertools:

  1391 		if self.gathertools:

  1406 			self.tools = tools.values()

  1392 			self.tools = tools.values()

  1407 		else:

  1393 		else:

  1408 			self.tools=[]

  1394 			self.tools=[]

  1415 

  1401 

  1416 		while unresolved:

  1402 		while unresolved:

  1417 			unresolved = False

  1403 			unresolved = False

  1418 			for k, v in self.dict.items():

  1404 			for k, v in self.dict.items():

  1419 				if v.find('$(' + k + ')') != -1:

  1405 				if v.find('$(' + k + ')') != -1:

  1422 				else:

  1408 				else:

  1423 					expanded = self.ExpandAll(v, specName, configName)

  1409 					expanded = self.ExpandAll(v, specName, configName)

  1424 

  1410 

  1425 				if expanded != v:				# something changed?

  1411 				if expanded != v:				# something changed?

  1426 					self.dict[k] = expanded

  1412 					self.dict[k] = expanded

  1464 

  1450 

  1465 		returns the newly expanded string."""

  1451 		returns the newly expanded string."""

  1466 

  1452 

  1467 		refs = Evaluator.refRegex.findall(value)

  1453 		refs = Evaluator.refRegex.findall(value)

  1468 

  1454 

  1469 		for r in set(refs):

  1459 		for r in set(refs):

  1470 			expansion = None

  1460 			expansion = None

  1471 

  1461 

  1475 				expansion = self.dict[r]

  1463 				expansion = self.dict[r]

  1476 			else:

  1464 			else:

  1477 				# no expansion for $(r)

  1465 				# no expansion for $(r)

  1480 			if expansion != None:

  1467 			if expansion != None:

  1481 				value = value.replace("$(" + r + ")", expansion)

  1468 				value = value.replace("$(" + r + ")", expansion)

  1482 

  1469 

  1483 		return value

  1473 		return value

  1484 

  1474 

  1485 

  1475 

  1486 # raptor_data module functions

  1476 # raptor_data module functions

  1487 

  1477