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.py | 593 -------------------------------- 1 file changed, 593 deletions(-) delete mode 100644 jam-files/boost-build/build/property.py (limited to 'jam-files/boost-build/build/property.py') diff --git a/jam-files/boost-build/build/property.py b/jam-files/boost-build/build/property.py deleted file mode 100644 index c4b13dbc..00000000 --- a/jam-files/boost-build/build/property.py +++ /dev/null @@ -1,593 +0,0 @@ -# Status: ported, except for tests and --abbreviate-paths. -# Base revision: 64070 -# -# Copyright 2001, 2002, 2003 Dave Abrahams -# Copyright 2006 Rene Rivera -# Copyright 2002, 2003, 2004, 2005, 2006 Vladimir Prus -# Distributed under the Boost Software License, Version 1.0. -# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) - -import re -from b2.util.utility import * -from b2.build import feature -from b2.util import sequence, qualify_jam_action -import b2.util.set -from b2.manager import get_manager - -__re_two_ampersands = re.compile ('&&') -__re_comma = re.compile (',') -__re_split_condition = re.compile ('(.*):(<.*)') -__re_split_conditional = re.compile (r'(.+):<(.+)') -__re_colon = re.compile (':') -__re_has_condition = re.compile (r':<') -__re_separate_condition_and_property = re.compile (r'(.*):(<.*)') - -class Property(object): - - __slots__ = ('_feature', '_value', '_condition') - - def __init__(self, f, value, condition = []): - if type(f) == type(""): - f = feature.get(f) - # At present, single property has a single value. - assert type(value) != type([]) - assert(f.free() or value.find(':') == -1) - self._feature = f - self._value = value - self._condition = condition - - def feature(self): - return self._feature - - def value(self): - return self._value - - def condition(self): - return self._condition - - def to_raw(self): - result = "<" + self._feature.name() + ">" + str(self._value) - if self._condition: - result = ",".join(str(p) for p in self._condition) + ':' + result - return result - - def __str__(self): - return self.to_raw() - - def __hash__(self): - # FIXME: consider if this class should be value-is-identity one - return hash((self._feature, self._value, tuple(self._condition))) - - def __cmp__(self, other): - return cmp((self._feature, self._value, self._condition), - (other._feature, other._value, other._condition)) - - -def create_from_string(s, allow_condition=False): - - condition = [] - import types - if not isinstance(s, types.StringType): - print type(s) - if __re_has_condition.search(s): - - if not allow_condition: - raise BaseException("Conditional property is not allowed in this context") - - m = __re_separate_condition_and_property.match(s) - condition = m.group(1) - s = m.group(2) - - # FIXME: break dependency cycle - from b2.manager import get_manager - - feature_name = get_grist(s) - if not feature_name: - if feature.is_implicit_value(s): - f = feature.implied_feature(s) - value = s - else: - raise get_manager().errors()("Invalid property '%s' -- unknown feature" % s) - else: - f = feature.get(feature_name) - - value = get_value(s) - if not value: - get_manager().errors()("Invalid property '%s' -- no value specified" % s) - - - if condition: - condition = [create_from_string(x) for x in condition.split(',')] - - return Property(f, value, condition) - -def create_from_strings(string_list, allow_condition=False): - - return [create_from_string(s, allow_condition) for s in string_list] - -def reset (): - """ Clear the module state. This is mainly for testing purposes. - """ - global __results - - # A cache of results from as_path - __results = {} - -reset () - - -def path_order (x, y): - """ Helper for as_path, below. Orders properties with the implicit ones - first, and within the two sections in alphabetical order of feature - name. - """ - if x == y: - return 0 - - xg = get_grist (x) - yg = get_grist (y) - - if yg and not xg: - return -1 - - elif xg and not yg: - return 1 - - else: - if not xg: - x = feature.expand_subfeatures([x]) - y = feature.expand_subfeatures([y]) - - if x < y: - return -1 - elif x > y: - return 1 - else: - return 0 - -def identify(string): - return string - -# Uses Property -def refine (properties, requirements): - """ Refines 'properties' by overriding any non-free properties - for which a different value is specified in 'requirements'. - Conditional requirements are just added without modification. - Returns the resulting list of properties. - """ - # The result has no duplicates, so we store it in a set - result = set() - - # Records all requirements. - required = {} - - # All the elements of requirements should be present in the result - # Record them so that we can handle 'properties'. - for r in requirements: - # Don't consider conditional requirements. - if not r.condition(): - required[r.feature()] = r - - for p in properties: - # Skip conditional properties - if p.condition(): - result.add(p) - # No processing for free properties - elif p.feature().free(): - result.add(p) - else: - if required.has_key(p.feature()): - result.add(required[p.feature()]) - else: - result.add(p) - - return sequence.unique(list(result) + requirements) - -def translate_paths (properties, path): - """ Interpret all path properties in 'properties' as relative to 'path' - The property values are assumed to be in system-specific form, and - will be translated into normalized form. - """ - result = [] - - for p in properties: - - if p.feature().path(): - values = __re_two_ampersands.split(p.value()) - - new_value = "&&".join(os.path.join(path, v) for v in values) - - if new_value != p.value(): - result.append(Property(p.feature(), new_value, p.condition())) - else: - result.append(p) - - else: - result.append (p) - - return result - -def translate_indirect(properties, context_module): - """Assumes that all feature values that start with '@' are - names of rules, used in 'context-module'. Such rules can be - either local to the module or global. Qualified local rules - with the name of the module.""" - result = [] - for p in properties: - if p.value()[0] == '@': - q = qualify_jam_action(p.value()[1:], context_module) - get_manager().engine().register_bjam_action(q) - result.append(Property(p.feature(), '@' + q, p.condition())) - else: - result.append(p) - - return result - -def validate (properties): - """ Exit with error if any of the properties is not valid. - properties may be a single property or a sequence of properties. - """ - - if isinstance (properties, str): - __validate1 (properties) - else: - for p in properties: - __validate1 (p) - -def expand_subfeatures_in_conditions (properties): - - result = [] - for p in properties: - - if not p.condition(): - result.append(p) - else: - expanded = [] - for c in p.condition(): - - if c.feature().name().startswith("toolset") or c.feature().name() == "os": - # It common that condition includes a toolset which - # was never defined, or mentiones subfeatures which - # were never defined. In that case, validation will - # only produce an spirious error, so don't validate. - expanded.extend(feature.expand_subfeatures ([c], True)) - else: - expanded.extend(feature.expand_subfeatures([c])) - - result.append(Property(p.feature(), p.value(), expanded)) - - return result - -# FIXME: this should go -def split_conditional (property): - """ If 'property' is conditional property, returns - condition and the property, e.g - debug,gcc:full will become - debug,gcc full. - Otherwise, returns empty string. - """ - m = __re_split_conditional.match (property) - - if m: - return (m.group (1), '<' + m.group (2)) - - return None - - -def select (features, properties): - """ Selects properties which correspond to any of the given features. - """ - result = [] - - # add any missing angle brackets - features = add_grist (features) - - return [p for p in properties if get_grist(p) in features] - -def validate_property_sets (sets): - for s in sets: - validate(s.all()) - -def evaluate_conditionals_in_context (properties, context): - """ Removes all conditional properties which conditions are not met - For those with met conditions, removes the condition. Properies - in conditions are looked up in 'context' - """ - base = [] - conditional = [] - - for p in properties: - if p.condition(): - conditional.append (p) - else: - base.append (p) - - result = base[:] - for p in conditional: - - # Evaluate condition - # FIXME: probably inefficient - if all(x in context for x in p.condition()): - result.append(Property(p.feature(), p.value())) - - return result - - -def change (properties, feature, value = None): - """ Returns a modified version of properties with all values of the - given feature replaced by the given value. - If 'value' is None the feature will be removed. - """ - result = [] - - feature = add_grist (feature) - - for p in properties: - if get_grist (p) == feature: - if value: - result.append (replace_grist (value, feature)) - - else: - result.append (p) - - return result - - -################################################################ -# Private functions - -def __validate1 (property): - """ Exit with error if property is not valid. - """ - msg = None - - if not property.feature().free(): - feature.validate_value_string (property.feature(), property.value()) - - -################################################################### -# Still to port. -# Original lines are prefixed with "# " -# -# -# import utility : ungrist ; -# import sequence : unique ; -# import errors : error ; -# import feature ; -# import regex ; -# import sequence ; -# import set ; -# import path ; -# import assert ; -# -# - - -# rule validate-property-sets ( property-sets * ) -# { -# for local s in $(property-sets) -# { -# validate [ feature.split $(s) ] ; -# } -# } -# - -def remove(attributes, properties): - """Returns a property sets which include all the elements - in 'properties' that do not have attributes listed in 'attributes'.""" - - result = [] - for e in properties: - attributes_new = feature.attributes(get_grist(e)) - has_common_features = 0 - for a in attributes_new: - if a in attributes: - has_common_features = 1 - break - - if not has_common_features: - result += e - - return result - - -def take(attributes, properties): - """Returns a property set which include all - properties in 'properties' that have any of 'attributes'.""" - result = [] - for e in properties: - if b2.util.set.intersection(attributes, feature.attributes(get_grist(e))): - result.append(e) - return result - -def translate_dependencies(properties, project_id, location): - - result = [] - for p in properties: - - if not p.feature().dependency(): - result.append(p) - else: - v = p.value() - m = re.match("(.*)//(.*)", v) - if m: - rooted = m.group(1) - if rooted[0] == '/': - # Either project id or absolute Linux path, do nothing. - pass - else: - rooted = os.path.join(os.getcwd(), location, rooted) - - result.append(Property(p.feature(), rooted + "//" + m.group(2), p.condition())) - - elif os.path.isabs(v): - result.append(p) - else: - result.append(Property(p.feature(), project_id + "//" + v, p.condition())) - - return result - - -class PropertyMap: - """ Class which maintains a property set -> string mapping. - """ - def __init__ (self): - self.__properties = [] - self.__values = [] - - def insert (self, properties, value): - """ Associate value with properties. - """ - self.__properties.append(properties) - self.__values.append(value) - - def find (self, properties): - """ Return the value associated with properties - or any subset of it. If more than one - subset has value assigned to it, return the - value for the longest subset, if it's unique. - """ - return self.find_replace (properties) - - def find_replace(self, properties, value=None): - matches = [] - match_ranks = [] - - for i in range(0, len(self.__properties)): - p = self.__properties[i] - - if b2.util.set.contains (p, properties): - matches.append (i) - match_ranks.append(len(p)) - - best = sequence.select_highest_ranked (matches, match_ranks) - - if not best: - return None - - if len (best) > 1: - raise NoBestMatchingAlternative () - - best = best [0] - - original = self.__values[best] - - if value: - self.__values[best] = value - - return original - -# local rule __test__ ( ) -# { -# import errors : try catch ; -# import feature ; -# import feature : feature subfeature compose ; -# -# # local rules must be explicitly re-imported -# import property : path-order ; -# -# feature.prepare-test property-test-temp ; -# -# feature toolset : gcc : implicit symmetric ; -# subfeature toolset gcc : version : 2.95.2 2.95.3 2.95.4 -# 3.0 3.0.1 3.0.2 : optional ; -# feature define : : free ; -# feature runtime-link : dynamic static : symmetric link-incompatible ; -# feature optimization : on off ; -# feature variant : debug release : implicit composite symmetric ; -# feature rtti : on off : link-incompatible ; -# -# compose debug : _DEBUG off ; -# compose release : NDEBUG on ; -# -# import assert ; -# import "class" : new ; -# -# validate gcc gcc-3.0.1 : $(test-space) ; -# -# assert.result gcc off FOO -# : refine gcc off -# : FOO -# : $(test-space) -# ; -# -# assert.result gcc on -# : refine gcc off -# : on -# : $(test-space) -# ; -# -# assert.result gcc off -# : refine gcc : off : $(test-space) -# ; -# -# assert.result gcc off off:FOO -# : refine gcc : off off:FOO -# : $(test-space) -# ; -# -# assert.result gcc:foo gcc:bar -# : refine gcc:foo : gcc:bar -# : $(test-space) -# ; -# -# assert.result MY_RELEASE -# : evaluate-conditionals-in-context -# release,off:MY_RELEASE -# : gcc release off -# -# ; -# -# try ; -# validate value : $(test-space) ; -# catch "Invalid property 'value': unknown feature 'feature'." ; -# -# try ; -# validate default : $(test-space) ; -# catch \"default\" is not a known value of feature ; -# -# validate WHATEVER : $(test-space) ; -# -# try ; -# validate : $(test-space) ; -# catch "Invalid property '': No value specified for feature 'rtti'." ; -# -# try ; -# validate value : $(test-space) ; -# catch "value" is not a value of an implicit feature ; -# -# -# assert.result on -# : remove free implicit : gcc foo on : $(test-space) ; -# -# assert.result a -# : select include : a gcc ; -# -# assert.result a -# : select include bar : a gcc ; -# -# assert.result a gcc -# : select include : a gcc ; -# -# assert.result kylix a -# : change gcc a : kylix ; -# -# # Test ordinary properties -# assert.result -# : split-conditional gcc -# ; -# -# # Test properties with ":" -# assert.result -# : split-conditional FOO=A::B -# ; -# -# # Test conditional feature -# assert.result gcc,3.0 FOO -# : split-conditional gcc,3.0:FOO -# ; -# -# feature.finish-test property-test-temp ; -# } -# - -- cgit v1.2.3