def expand_composites (properties): """ Expand all composite properties in the set so that all components are explicitly expressed. """ explicit_features = get_grist (properties) result = [] # now expand composite features for p in properties: expanded = expand_composite (p) for x in expanded: if not x in result: f = get_grist (x) if f in __free_features: result.append (x) elif not x in properties: # x is the result of expansion if not f in explicit_features: # not explicitly-specified if f in get_grist (result): raise FeatureConflict ("expansions of composite features result in " "conflicting values for '%s'\nvalues: '%s'\none contributing composite property was '%s'" % (f, get_values (f, result) + [replace_grist (x, '')], p)) else: result.append (x) elif f in get_grist (result): raise FeatureConflict ("explicitly-specified values of non-free feature '%s' conflict\n" "existing values: '%s'\nvalue from expanding '%s': '%s'" % (f, get_values (f, properties), p, replace_grist (x, ''))) else: result.append (x) return result
def __expand_subfeatures_aux(feature, value, dont_validate=False): """ Helper for expand_subfeatures. Given a feature and value, or just a value corresponding to an implicit feature, returns a property set consisting of all component subfeatures and their values. For example: expand_subfeatures <toolset>gcc-2.95.2-linux-x86 -> <toolset>gcc <toolset-version>2.95.2 <toolset-os>linux <toolset-cpu>x86 equivalent to: expand_subfeatures gcc-2.95.2-linux-x86 feature: The name of the feature, or empty if value corresponds to an implicit property value: The value of the feature. dont_validate: If True, no validation of value string will be done. """ if not feature: feature = implied_feature(value) else: validate_feature(feature) if not dont_validate: validate_value_string(feature, value) components = value.split("-") # get the top-level feature's value value = replace_grist(components[0], '') result = [replace_grist(components[0], feature)] subvalues = components[1:] while len(subvalues) > 0: subvalue = subvalues[0] # pop the head off of subvalues subvalues = subvalues[1:] subfeature = __find_implied_subfeature(feature, subvalue, value) # If no subfeature was found, reconstitute the value string and use that if not subfeature: result = '-'.join(components) result = replace_grist(result, feature) return [result] f = ungrist(feature) # FIXME: why grist includes '<>'? result.append(replace_grist(subvalue, '<' + f + '-' + subfeature + '>')) return result
def __expand_subfeatures_aux (feature, value, dont_validate = False): """ Helper for expand_subfeatures. Given a feature and value, or just a value corresponding to an implicit feature, returns a property set consisting of all component subfeatures and their values. For example: expand_subfeatures <toolset>gcc-2.95.2-linux-x86 -> <toolset>gcc <toolset-version>2.95.2 <toolset-os>linux <toolset-cpu>x86 equivalent to: expand_subfeatures gcc-2.95.2-linux-x86 feature: The name of the feature, or empty if value corresponds to an implicit property value: The value of the feature. dont_validate: If True, no validation of value string will be done. """ if not feature: feature = implied_feature(value) else: validate_feature(feature) if not dont_validate: validate_value_string(feature, value) components = value.split ("-") # get the top-level feature's value value = replace_grist(components[0], '') result = [ replace_grist(components[0], feature) ] subvalues = components[1:] while len(subvalues) > 0: subvalue = subvalues [0] # pop the head off of subvalues subvalues = subvalues [1:] subfeature = __find_implied_subfeature (feature, subvalue, value) # If no subfeature was found, reconstitute the value string and use that if not subfeature: result = '-'.join(components) result = replace_grist (result, feature) return [result] f = ungrist (feature) # FIXME: why grist includes '<>'? result.append (replace_grist (subvalue, '<' + f + '-' + subfeature + '>')) return result
def actualize (self, scanner = None): """ Generates all the actual targets and sets up build actions for this target. If 'scanner' is specified, creates an additional target with the same location as actual target, which will depend on the actual target and be associated with 'scanner'. That additional target is returned. See the docs (#dependency_scanning) for rationale. Target must correspond to a file if 'scanner' is specified. If scanner is not specified, then actual target is returned. """ actual_name = self.actualize_no_scanner () if not scanner: return actual_name else: # Add the scanner instance to the grist for name. g = '-'.join ([ungrist(get_grist(actual_name)), str(id(scanner))]) name = replace_grist (actual_name, '<' + g + '>') if not self.made_.has_key (name): self.made_ [name] = True self.project_.manager ().engine ().add_dependency (name, actual_name) self.actualize_location (name) self.project_.manager ().scanners ().install (scanner, name, str (self)) return name
def is_subfeature_of (parent_property, f): """ Return true iff f is an ordinary subfeature of the parent_property's feature, or if f is a subfeature of the parent_property's feature specific to the parent_property's value. """ if not valid (f) or not 'subfeature' in __all_features [f]['attributes']: return False specific_subfeature = __re_split_subfeatures.match (f) if specific_subfeature: # The feature has the form # <topfeature-topvalue:subfeature>, # e.g. <toolset-msvc:version> feature_value = split_top_feature(specific_subfeature.group(1)) if replace_grist (feature_value [1], '<' + feature_value [0] + '>') == parent_property: return True else: # The feature has the form <topfeature-subfeature>, # e.g. <toolset-version> top_sub = split_top_feature (ungrist (f)) if top_sub [1] and add_grist (top_sub [0]) == get_grist (parent_property): return True return False
def is_subfeature_of(parent_property, f): """ Return true iff f is an ordinary subfeature of the parent_property's feature, or if f is a subfeature of the parent_property's feature specific to the parent_property's value. """ if not valid(f) or not 'subfeature' in __all_features[f]['attributes']: return False specific_subfeature = __re_split_subfeatures.match(f) if specific_subfeature: # The feature has the form # <topfeature-topvalue:subfeature>, # e.g. <toolset-msvc:version> feature_value = split_top_feature(specific_subfeature.group(1)) if replace_grist(feature_value[1], '<' + feature_value[0] + '>') == parent_property: return True else: # The feature has the form <topfeature-subfeature>, # e.g. <toolset-version> top_sub = split_top_feature(ungrist(f)) if top_sub[1] and add_grist(top_sub[0]) == get_grist(parent_property): return True return False
def expand_subfeatures (properties, dont_validate = False): """ Make all elements of properties corresponding to implicit features explicit, and express all subfeature values as separate properties in their own right. For example, the property gcc-2.95.2-linux-x86 might expand to <toolset>gcc <toolset-version>2.95.2 <toolset-os>linux <toolset-cpu>x86 properties: A sequence with elements of the form <feature>value-string or just value-string in the case of implicit features. : dont_validate: If True, no validation of value string will be done. """ result = [] for p in properties: p_grist = get_grist (p) # Don't expand subfeatures in subfeatures if ':' in p_grist: result.append (p) else: result.extend (__expand_subfeatures_aux (p_grist, replace_grist (p, ''), dont_validate)) return result
def __init__ (self, main_target, prop_set, sources, build_properties, sources_usage_requirements, created_targets): """ main_target: The instance of MainTarget class prop_set: Properties requested for this target sources: build_properties: Actually used properties sources_usage_requirements: Properties propagated from sources created_targets: Top-level created targets """ self.main_target_ = main_target self.properties_ = prop_set self.sources_ = sources self.build_properties_ = build_properties self.sources_usage_requirements_ = sources_usage_requirements self.created_targets_ = created_targets self.usage_requirements_ = None # Pre-compose the list of other dependency graphs, on which this one # depends deps = build_properties.get ('<implicit-dependency>') self.other_dg_ = [] for d in deps: # FIXME: the property must have the actual object here, not a string. value = replace_grist (d, '') self.other_dg_.append (value.creating_subvariant ()) self.other_dg_ = unique (self.other_dg_) self.implicit_includes_cache_ = {} self.target_directories_ = None
def expand_subfeatures(properties, dont_validate=False): """ Make all elements of properties corresponding to implicit features explicit, and express all subfeature values as separate properties in their own right. For example, the property gcc-2.95.2-linux-x86 might expand to <toolset>gcc <toolset-version>2.95.2 <toolset-os>linux <toolset-cpu>x86 properties: A sequence with elements of the form <feature>value-string or just value-string in the case of implicit features. : dont_validate: If True, no validation of value string will be done. """ result = [] for p in properties: p_grist = get_grist(p) # Don't expand subfeatures in subfeatures if ':' in p_grist: result.append(p) else: result.extend( __expand_subfeatures_aux(p_grist, replace_grist(p, ''), dont_validate)) return result
def register(type, suffixes=[], base_type=None): """ Registers a target type, possibly derived from a 'base-type'. If 'suffixes' are provided, they list all the suffixes that mean a file is of 'type'. Also, the first element gives the suffix to be used when constructing and object of 'type'. type: a string suffixes: None or a sequence of strings base_type: None or a string """ # Type names cannot contain hyphens, because when used as # feature-values they will be interpreted as composite features # which need to be decomposed. if __re_hyphen.search(type): raise BaseException('type name "%s" contains a hyphen' % type) # it's possible for a type to be registered with a # base type that hasn't been registered yet. in the # check for base_type below and the following calls to setdefault() # the key `type` will be added to __types. When the base type # actually gets registered, it would fail after the simple check # of "type in __types"; thus the check for "'base' in __types[type]" if type in __types and 'base' in __types[type]: raise BaseException('Type "%s" is already registered.' % type) entry = __types.setdefault(type, {}) entry['base'] = base_type entry.setdefault('derived', []) entry.setdefault('scanner', None) if base_type: __types.setdefault(base_type, {}).setdefault('derived', []).append(type) if len(suffixes) > 0: # Generated targets of 'type' will use the first of 'suffixes' # (this may be overridden) set_generated_target_suffix(type, [], suffixes[0]) # Specify mapping from suffixes to type register_suffixes(suffixes, type) feature.extend('target-type', [type]) feature.extend('main-target-type', [type]) feature.extend('base-target-type', [type]) if base_type: feature.compose('<target-type>' + type, [replace_grist(base_type, '<base-target-type>')]) feature.compose('<base-target-type>' + type, ['<base-target-type>' + base_type]) import b2.build.generators as generators # Adding a new derived type affects generator selection so we need to # make the generator selection module update any of its cached # information related to a new derived type being defined. generators.update_cached_information_with_a_new_type(type) # FIXME: resolving recursive dependency. from b2.manager import get_manager get_manager().projects().project_rules().add_rule_for_type(type)
def register(type, suffixes=[], base_type=None): """ Registers a target type, possibly derived from a 'base-type'. If 'suffixes' are provided, they list all the suffixes that mean a file is of 'type'. Also, the first element gives the suffix to be used when constructing and object of 'type'. type: a string suffixes: None or a sequence of strings base_type: None or a string """ # Type names cannot contain hyphens, because when used as # feature-values they will be interpreted as composite features # which need to be decomposed. if __re_hyphen.search(type): raise BaseException('type name "%s" contains a hyphen' % type) # it's possible for a type to be registered with a # base type that hasn't been registered yet. in the # check for base_type below and the following calls to setdefault() # the key `type` will be added to __types. When the base type # actually gets registered, it would fail after the simple check # of "type in __types"; thus the check for "'base' in __types[type]" if type in __types and "base" in __types[type]: raise BaseException('Type "%s" is already registered.' % type) entry = __types.setdefault(type, {}) entry["base"] = base_type entry.setdefault("derived", []) entry.setdefault("scanner", None) if base_type: __types.setdefault(base_type, {}).setdefault("derived", []).append(type) if len(suffixes) > 0: # Generated targets of 'type' will use the first of 'suffixes' # (this may be overriden) set_generated_target_suffix(type, [], suffixes[0]) # Specify mapping from suffixes to type register_suffixes(suffixes, type) feature.extend("target-type", [type]) feature.extend("main-target-type", [type]) feature.extend("base-target-type", [type]) if base_type: feature.compose("<target-type>" + type, [replace_grist(base_type, "<base-target-type>")]) feature.compose("<base-target-type>" + type, ["<base-target-type>" + base_type]) import b2.build.generators as generators # Adding a new derived type affects generator selection so we need to # make the generator selection module update any of its cached # information related to a new derived type being defined. generators.update_cached_information_with_a_new_type(type) # FIXME: resolving recursive dependency. from b2.manager import get_manager get_manager().projects().project_rules().add_rule_for_type(type)
def get_values (feature, properties): """ Returns all values of the given feature specified by the given property set. """ result = [] for p in properties: if get_grist (p) == feature: result.append (replace_grist (p, '')) return result
def get_values(feature, properties): """ Returns all values of the given feature specified by the given property set. """ result = [] for p in properties: if get_grist(p) == feature: result.append(replace_grist(p, '')) return result
def register(type, suffixes=[], base_type=None): """ Registers a target type, possibly derived from a 'base-type'. If 'suffixes' are provided, they list all the suffixes that mean a file is of 'type'. Also, the first element gives the suffix to be used when constructing and object of 'type'. type: a string suffixes: None or a sequence of strings base_type: None or a string """ # Type names cannot contain hyphens, because when used as # feature-values they will be interpreted as composite features # which need to be decomposed. if __re_hyphen.search(type): raise BaseException('type name "%s" contains a hyphen' % type) if __types.has_key(type): raise BaseException('Type "%s" is already registered.' % type) entry = {} entry['base'] = base_type entry['derived'] = [] entry['scanner'] = None __types[type] = entry if base_type: __types[base_type]['derived'].append(type) if len(suffixes) > 0: # Generated targets of 'type' will use the first of 'suffixes' # (this may be overriden) set_generated_target_suffix(type, [], suffixes[0]) # Specify mapping from suffixes to type register_suffixes(suffixes, type) feature.extend('target-type', [type]) feature.extend('main-target-type', [type]) feature.extend('base-target-type', [type]) if base_type: feature.compose('<target-type>' + type, replace_grist(base_type, '<base-target-type>')) feature.compose('<base-target-type>' + type, '<base-target-type>' + base_type) import b2.build.generators as generators # Adding a new derived type affects generator selection so we need to # make the generator selection module update any of its cached # information related to a new derived type being defined. generators.update_cached_information_with_a_new_type(type) # FIXME: resolving recursive dependency. from b2.manager import get_manager get_manager().projects().project_rules().add_rule_for_type(type)
def register(type, suffixes=[], base_type=None): """ Registers a target type, possibly derived from a 'base-type'. If 'suffixes' are provided, they list all the suffixes that mean a file is of 'type'. Also, the first element gives the suffix to be used when constructing and object of 'type'. type: a string suffixes: None or a sequence of strings base_type: None or a string """ # Type names cannot contain hyphens, because when used as # feature-values they will be interpreted as composite features # which need to be decomposed. if __re_hyphen.search(type): raise BaseException('type name "%s" contains a hyphen' % type) if __types.has_key(type): raise BaseException('Type "%s" is already registered.' % type) entry = {} entry["base"] = base_type entry["derived"] = [] entry["scanner"] = None __types[type] = entry if base_type: __types[base_type]["derived"].append(type) if len(suffixes) > 0: # Generated targets of 'type' will use the first of 'suffixes' # (this may be overriden) set_generated_target_suffix(type, [], suffixes[0]) # Specify mapping from suffixes to type register_suffixes(suffixes, type) feature.extend("target-type", [type]) feature.extend("main-target-type", [type]) feature.extend("base-target-type", [type]) if base_type: feature.compose("<target-type>" + type, replace_grist(base_type, "<base-target-type>")) feature.compose("<base-target-type>" + type, "<base-target-type>" + base_type) import b2.build.generators as generators # Adding a new derived type affects generator selection so we need to # make the generator selection module update any of its cached # information related to a new derived type being defined. generators.update_cached_information_with_a_new_type(type) # FIXME: resolving recursive dependency. from b2.manager import get_manager get_manager().projects().project_rules().add_rule_for_type(type)
def defaults(features): """ Returns the default property values for the given features. """ result = [] for f in features: attributes = __all_features[f]['attributes'] if not 'free' in attributes and not 'optional' in attributes: defaults = __all_features[f]['default'] if defaults: result.append(replace_grist(defaults, f)) return result
def defaults (features): """ Returns the default property values for the given features. """ result = [] for f in features: attributes = __all_features [f]['attributes'] if not 'free' in attributes and not 'optional' in attributes: defaults = __all_features [f]['default'] if defaults: result.append (replace_grist (defaults, f)) return result
def add_defaults(properties): """ Given a set of properties, add default values for features not represented in the set. Note: if there's there's ordinary feature F1 and composite feature F2, which includes some value for F1, and both feature have default values, then the default value of F1 will be added, not the value in F2. This might not be right idea: consider feature variant : debug ... ; <variant>debug : .... <runtime-debugging>on feature <runtime-debugging> : off on ; Here, when adding default for an empty property set, we'll get <variant>debug <runtime_debugging>off and that's kind of strange. """ result = [x for x in properties] for v in replace_grist(properties, ''): if v in properties: raise BaseException( "'add_defaults' requires explicitly specified features, but '%s' appears to be the value of an un-expanded implicit feature" % v) # We don't add default for elements with ":" inside. This catches: # 1. Conditional properties --- we don't want <variant>debug:<define>DEBUG # to be takes as specified value for <variant> # 2. Free properties with ":" in values. We don't care, since free properties # don't have defaults. xproperties = [ property for property in properties if __re_no_hyphen.match(property) ] missing_top = set.difference(__all_top_features, get_grist(xproperties)) more = defaults(missing_top) result += more xproperties += more # Add defaults for subfeatures of features which are present for p in xproperties: gp = get_grist(p) s = [] if __all_features.has_key(gp): s = __all_features[gp]['subfeatures'] f = ungrist(gp) xbase = ['<%s-%s>' % (f, xs) for xs in s] missing_subs = set.difference(xbase, get_grist(result)) result += defaults(__select_subfeatures(p, missing_subs)) return result
def process(self, target, matches, binding): # create a single string so that findall # can be used since it returns a list of # all grouped matches match_str = ' '.join(matches) # the question mark makes the regexes non-greedy angles = re.findall(r'<(.*?)>', match_str) quoted = re.findall(r'"(.*?)"', match_str) # CONSIDER: the new scoping rules seem to defeat "on target" variables. g = ENGINE.get_target_variable(target, 'HDRGRIST') b = os.path.normpath(os.path.dirname(binding)) # Attach binding of including file to included targets. When a target is # directly created from a virtual target this extra information is # unnecessary. But in other cases, it allows us to distinguish between # two headers of the same name included from different places. We do not # need this extra information for angle includes, since they should not # depend on the including file (we can not get literal "." in the # include path). # local g2 = $(g)"#"$(b) ; g2 = g + '#' + b angles = [replace_grist(angle, g) for angle in angles] quoted = [replace_grist(quote, g2) for quote in quoted] includes = angles + quoted bjam.call('INCLUDES', target, includes) bjam.call('NOCARE', includes) ENGINE.set_target_variable(angles, 'SEARCH', self.includes) ENGINE.set_target_variable(quoted, 'SEARCH', [b] + self.includes) # Just propagate the current scanner to includes, in hope that includes # do not change scanners. SCANNERS.propagate(self, includes) bjam.call('ISFILE', includes)
def add_defaults (properties): """ Given a set of properties, add default values for features not represented in the set. Note: if there's there's ordinary feature F1 and composite feature F2, which includes some value for F1, and both feature have default values, then the default value of F1 will be added, not the value in F2. This might not be right idea: consider feature variant : debug ... ; <variant>debug : .... <runtime-debugging>on feature <runtime-debugging> : off on ; Here, when adding default for an empty property set, we'll get <variant>debug <runtime_debugging>off and that's kind of strange. """ result = [ x for x in properties ] for v in replace_grist (properties, ''): if v in properties: raise BaseException ("'add_defaults' requires explicitly specified features, but '%s' appears to be the value of an un-expanded implicit feature" % v) # We don't add default for elements with ":" inside. This catches: # 1. Conditional properties --- we don't want <variant>debug:<define>DEBUG # to be takes as specified value for <variant> # 2. Free properties with ":" in values. We don't care, since free properties # don't have defaults. xproperties = [ property for property in properties if __re_no_hyphen.match (property) ] missing_top = set.difference (__all_top_features, get_grist (xproperties)) more = defaults (missing_top) result += more xproperties += more # Add defaults for subfeatures of features which are present for p in xproperties: gp = get_grist (p) s = [] if __all_features.has_key (gp): s = __all_features [gp]['subfeatures'] f = ungrist (gp) xbase = ['<%s-%s>' % (f, xs) for xs in s] missing_subs = set.difference (xbase, get_grist (result)) result += defaults (__select_subfeatures (p, missing_subs)) return result
def minimize (properties): """ Given an expanded property set, eliminate all redundancy: properties which are elements of other (composite) properties in the set will be eliminated. Non-symmetric properties equal to default values will be eliminated, unless the override a value from some composite property. Implicit properties will be expressed without feature grist, and sub-property values will be expressed as elements joined to the corresponding main property. """ # FXIME: the code below was in the original feature.jam file, however 'p' is not defined. # # Precondition checking # local implicits = [ set.intersection $(p:G=) : $(p:G) ] ; # if $(implicits) # { # error minimize requires an expanded property set, but \"$(implicits[1])\" # appears to be the value of an un-expanded implicit feature ; # } # remove properties implied by composite features components = [] for property in properties: if __composite_properties.has_key (property): components.extend (__composite_properties [property]['components']) x = set.difference (properties, components) # handle subfeatures and implicit features x = __move_subfeatures_to_the_end (x) result = [] while x: fullp = x [0] p = fullp f = get_grist (p) v = replace_grist (p, '') # eliminate features in implicit properties. if 'implicit' in __all_features [f]['attributes']: p = v # locate all subproperties of $(x[1]) in the property set subproperties = __select_subproperties (fullp, x) if subproperties: # reconstitute the joined property name subproperties.sort () joined = p + '-' + '-'.join (replace_grist (subproperties, '')) result.append (joined) x = set.difference (x [1:], subproperties) else: # eliminate properties whose value is equal to feature's # default and which are not symmetric and which do not # contradict values implied by composite properties. # since all component properties of composites in the set # have been eliminated, any remaining property whose # feature is the same as a component of a composite in the # set must have a non-redundant value. if [fullp] != defaults ([f]) or 'symmetric' in attributes (f)\ or get_grist (fullp) in get_grist (components): result.append (p) x = x [1:] return result
def __init__(self, includes): scanner.Scanner.__init__(self) self.includes = [] for include in includes: self.includes.extend(replace_grist(include, '').split('&&'))
def minimize(properties): """ Given an expanded property set, eliminate all redundancy: properties which are elements of other (composite) properties in the set will be eliminated. Non-symmetric properties equal to default values will be eliminated, unless the override a value from some composite property. Implicit properties will be expressed without feature grist, and sub-property values will be expressed as elements joined to the corresponding main property. """ # FXIME: the code below was in the original feature.jam file, however 'p' is not defined. # # Precondition checking # local implicits = [ set.intersection $(p:G=) : $(p:G) ] ; # if $(implicits) # { # error minimize requires an expanded property set, but \"$(implicits[1])\" # appears to be the value of an un-expanded implicit feature ; # } # remove properties implied by composite features components = [] for property in properties: if __composite_properties.has_key(property): components.extend(__composite_properties[property]['components']) x = set.difference(properties, components) # handle subfeatures and implicit features x = __move_subfeatures_to_the_end(x) result = [] while x: fullp = x[0] p = fullp f = get_grist(p) v = replace_grist(p, '') # eliminate features in implicit properties. if 'implicit' in __all_features[f]['attributes']: p = v # locate all subproperties of $(x[1]) in the property set subproperties = __select_subproperties(fullp, x) if subproperties: # reconstitute the joined property name subproperties.sort() joined = p + '-' + '-'.join(replace_grist(subproperties, '')) result.append(joined) x = set.difference(x[1:], subproperties) else: # eliminate properties whose value is equal to feature's # default and which are not symmetric and which do not # contradict values implied by composite properties. # since all component properties of composites in the set # have been eliminated, any remaining property whose # feature is the same as a component of a composite in the # set must have a non-redundant value. if [fullp] != defaults ([f]) or 'symmetric' in attributes (f)\ or get_grist (fullp) in get_grist (components): result.append(p) x = x[1:] return result