From e26434979adc33bd949566ba7bf02dff64e80a3e Mon Sep 17 00:00:00 2001 From: Chris Dyer Date: Tue, 2 Oct 2012 00:19:43 -0400 Subject: cdec cleanup, remove bayesian stuff, parsing stuff --- jam-files/boost-build/build/property_set.py | 449 ---------------------------- 1 file changed, 449 deletions(-) delete mode 100644 jam-files/boost-build/build/property_set.py (limited to 'jam-files/boost-build/build/property_set.py') diff --git a/jam-files/boost-build/build/property_set.py b/jam-files/boost-build/build/property_set.py deleted file mode 100644 index f12eb90c..00000000 --- a/jam-files/boost-build/build/property_set.py +++ /dev/null @@ -1,449 +0,0 @@ -# Status: ported. -# Base revision: 40480 - -# Copyright (C) Vladimir Prus 2002. Permission to copy, use, modify, sell and -# distribute this software is granted provided this copyright notice appears in -# all copies. This software is provided "as is" without express or implied -# warranty, and with no claim as to its suitability for any purpose. - -from b2.util.utility import * -import property, feature, string -import b2.build.feature -from b2.exceptions import * -from b2.util.sequence import unique -from b2.util.set import difference -from b2.util import cached - -from b2.manager import get_manager - - -def reset (): - """ Clear the module state. This is mainly for testing purposes. - """ - global __cache - - # A cache of property sets - # TODO: use a map of weak refs? - __cache = {} - -reset () - - -def create (raw_properties = []): - """ Creates a new 'PropertySet' instance for the given raw properties, - or returns an already existing one. - """ - # FIXME: propagate to callers. - if len(raw_properties) > 0 and isinstance(raw_properties[0], property.Property): - x = raw_properties - else: - x = [property.create_from_string(ps) for ps in raw_properties] - x.sort() - x = unique (x) - - # FIXME: can we do better, e.g. by directly computing - # has value of the list? - key = tuple(x) - - if not __cache.has_key (key): - __cache [key] = PropertySet(x) - - return __cache [key] - -def create_with_validation (raw_properties): - """ Creates new 'PropertySet' instances after checking - that all properties are valid and converting incidental - properties into gristed form. - """ - properties = [property.create_from_string(s) for s in raw_properties] - property.validate(properties) - - return create(properties) - -def empty (): - """ Returns PropertySet with empty set of properties. - """ - return create () - -def create_from_user_input(raw_properties, jamfile_module, location): - """Creates a property-set from the input given by the user, in the - context of 'jamfile-module' at 'location'""" - - properties = property.create_from_strings(raw_properties, True) - properties = property.translate_paths(properties, location) - properties = property.translate_indirect(properties, jamfile_module) - - project_id = get_manager().projects().attributeDefault(jamfile_module, 'id', None) - if not project_id: - project_id = os.path.abspath(location) - properties = property.translate_dependencies(properties, project_id, location) - properties = property.expand_subfeatures_in_conditions(properties) - return create(properties) - - -def refine_from_user_input(parent_requirements, specification, jamfile_module, - location): - """Refines requirements with requirements provided by the user. - Specially handles "-value" syntax in specification - to remove given requirements. - - parent-requirements -- property-set object with requirements - to refine - - specification -- string list of requirements provided by the use - - project-module -- the module to which context indirect features - will be bound. - - location -- the path to which path features are relative.""" - - - if not specification: - return parent_requirements - - - add_requirements = [] - remove_requirements = [] - - for r in specification: - if r[0] == '-': - remove_requirements.append(r[1:]) - else: - add_requirements.append(r) - - if remove_requirements: - # Need to create property set, so that path features - # and indirect features are translated just like they - # are in project requirements. - ps = create_from_user_input(remove_requirements, - jamfile_module, location) - - parent_requirements = create(difference(parent_requirements.all(), - ps.all())) - specification = add_requirements - - requirements = create_from_user_input(specification, - jamfile_module, location) - - return parent_requirements.refine(requirements) - -class PropertySet: - """ Class for storing a set of properties. - - there's 1<->1 correspondence between identity and value. No - two instances of the class are equal. To maintain this property, - the 'PropertySet.create' rule should be used to create new instances. - Instances are immutable. - - - each property is classified with regard to it's effect on build - results. Incidental properties have no effect on build results, from - Boost.Build point of view. Others are either free, or non-free, which we - call 'base'. Each property belong to exactly one of those categories and - it's possible to get list of properties in each category. - - In addition, it's possible to get list of properties with specific - attribute. - - - several operations, like and refine and as_path are provided. They all use - caching whenever possible. - """ - def __init__ (self, properties = []): - - - raw_properties = [] - for p in properties: - raw_properties.append(p.to_raw()) - - self.all_ = properties - self.all_raw_ = raw_properties - self.all_set_ = set(properties) - - self.incidental_ = [] - self.free_ = [] - self.base_ = [] - self.dependency_ = [] - self.non_dependency_ = [] - self.conditional_ = [] - self.non_conditional_ = [] - self.propagated_ = [] - self.link_incompatible = [] - - # A cache of refined properties. - self.refined_ = {} - - # A cache of property sets created by adding properties to this one. - self.added_ = {} - - # Cache for the default properties. - self.defaults_ = None - - # Cache for the expanded properties. - self.expanded_ = None - - # Cache for the expanded composite properties - self.composites_ = None - - # Cache for property set with expanded subfeatures - self.subfeatures_ = None - - # Cache for the property set containing propagated properties. - self.propagated_ps_ = None - - # A map of features to its values. - self.feature_map_ = None - - # A tuple (target path, is relative to build directory) - self.target_path_ = None - - self.as_path_ = None - - # A cache for already evaluated sets. - self.evaluated_ = {} - - for p in raw_properties: - if not get_grist (p): - raise BaseException ("Invalid property: '%s'" % p) - - att = feature.attributes (get_grist (p)) - - if 'propagated' in att: - self.propagated_.append (p) - - if 'link_incompatible' in att: - self.link_incompatible.append (p) - - for p in properties: - - # A feature can be both incidental and free, - # in which case we add it to incidental. - if p.feature().incidental(): - self.incidental_.append(p) - elif p.feature().free(): - self.free_.append(p) - else: - self.base_.append(p) - - if p.condition(): - self.conditional_.append(p) - else: - self.non_conditional_.append(p) - - if p.feature().dependency(): - self.dependency_.append (p) - else: - self.non_dependency_.append (p) - - - def all(self): - return self.all_ - - def raw (self): - """ Returns the list of stored properties. - """ - return self.all_raw_ - - def __str__(self): - return ' '.join(str(p) for p in self.all_) - - def base (self): - """ Returns properties that are neither incidental nor free. - """ - return self.base_ - - def free (self): - """ Returns free properties which are not dependency properties. - """ - return self.free_ - - def non_free(self): - return self.base_ + self.incidental_ - - def dependency (self): - """ Returns dependency properties. - """ - return self.dependency_ - - def non_dependency (self): - """ Returns properties that are not dependencies. - """ - return self.non_dependency_ - - def conditional (self): - """ Returns conditional properties. - """ - return self.conditional_ - - def non_conditional (self): - """ Returns properties that are not conditional. - """ - return self.non_conditional_ - - def incidental (self): - """ Returns incidental properties. - """ - return self.incidental_ - - def refine (self, requirements): - """ Refines this set's properties using the requirements passed as an argument. - """ - assert isinstance(requirements, PropertySet) - if not self.refined_.has_key (requirements): - r = property.refine(self.all_, requirements.all_) - - self.refined_[requirements] = create(r) - - return self.refined_[requirements] - - def expand (self): - if not self.expanded_: - expanded = feature.expand(self.all_) - self.expanded_ = create(expanded) - return self.expanded_ - - def expand_subfeatures(self): - if not self.subfeatures_: - self.subfeatures_ = create(feature.expand_subfeatures(self.all_)) - return self.subfeatures_ - - def evaluate_conditionals(self, context=None): - if not context: - context = self - - if not self.evaluated_.has_key(context): - # FIXME: figure why the call messes up first parameter - self.evaluated_[context] = create( - property.evaluate_conditionals_in_context(self.all(), context)) - - return self.evaluated_[context] - - def propagated (self): - if not self.propagated_ps_: - self.propagated_ps_ = create (self.propagated_) - return self.propagated_ps_ - - def add_defaults (self): - # FIXME: this caching is invalidated when new features - # are declare inside non-root Jamfiles. - if not self.defaults_: - expanded = feature.add_defaults(self.all_) - self.defaults_ = create(expanded) - return self.defaults_ - - def as_path (self): - if not self.as_path_: - - def path_order (p1, p2): - - i1 = p1.feature().implicit() - i2 = p2.feature().implicit() - - if i1 != i2: - return i2 - i1 - else: - return cmp(p1.feature().name(), p2.feature().name()) - - # trim redundancy - properties = feature.minimize(self.base_) - - # sort according to path_order - properties.sort (path_order) - - components = [] - for p in properties: - if p.feature().implicit(): - components.append(p.value()) - else: - components.append(p.feature().name() + "-" + p.value()) - - self.as_path_ = '/'.join (components) - - return self.as_path_ - - def target_path (self): - """ Computes the target path that should be used for - target with these properties. - Returns a tuple of - - the computed path - - if the path is relative to build directory, a value of - 'true'. - """ - if not self.target_path_: - # The feature can be used to explicitly - # change the location of generated targets - l = self.get ('') - if l: - computed = l[0] - is_relative = False - - else: - p = self.as_path () - - # Really, an ugly hack. Boost regression test system requires - # specific target paths, and it seems that changing it to handle - # other directory layout is really hard. For that reason, - # we teach V2 to do the things regression system requires. - # The value o '' is predended to the path. - prefix = self.get ('') - - if prefix: - if len (prefix) > 1: - raise AlreadyDefined ("Two properties specified: '%s'" % prefix) - - computed = os.path.join(prefix[0], p) - - else: - computed = p - - if not computed: - computed = "." - - is_relative = True - - self.target_path_ = (computed, is_relative) - - return self.target_path_ - - def add (self, ps): - """ Creates a new property set containing the properties in this one, - plus the ones of the property set passed as argument. - """ - if not self.added_.has_key(ps): - self.added_[ps] = create(self.all_ + ps.all()) - return self.added_[ps] - - def add_raw (self, properties): - """ Creates a new property set containing the properties in this one, - plus the ones passed as argument. - """ - return self.add (create (properties)) - - - def get (self, feature): - """ Returns all values of 'feature'. - """ - if type(feature) == type([]): - feature = feature[0] - if not isinstance(feature, b2.build.feature.Feature): - feature = b2.build.feature.get(feature) - - if not self.feature_map_: - self.feature_map_ = {} - - for v in self.all_: - if not self.feature_map_.has_key(v.feature()): - self.feature_map_[v.feature()] = [] - self.feature_map_[v.feature()].append(v.value()) - - return self.feature_map_.get(feature, []) - - @cached - def get_properties(self, feature): - """Returns all contained properties associated with 'feature'""" - - if not isinstance(feature, b2.build.feature.Feature): - feature = b2.build.feature.get(feature) - - result = [] - for p in self.all_: - if p.feature() == feature: - result.append(p) - return result - - def __contains__(self, item): - return item in self.all_set_ - -- cgit v1.2.3