| # Copyright 2001, 2002, 2003 Dave Abrahams |
| # Copyright 2002, 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 assert : * ; |
| import "class" : * ; |
| import errors : lol->list ; |
| import indirect ; |
| import modules ; |
| import regex ; |
| import sequence ; |
| import set ; |
| import utility ; |
| |
| |
| local rule setup ( ) |
| { |
| .all-attributes = |
| implicit |
| composite |
| optional |
| symmetric |
| free |
| incidental |
| path |
| dependency |
| propagated |
| link-incompatible |
| subfeature |
| order-sensitive |
| ; |
| |
| .all-features = ; |
| .all-subfeatures = ; |
| .all-top-features = ; # non-subfeatures |
| .all-implicit-values = ; |
| } |
| setup ; |
| |
| |
| # Prepare a fresh space to test in by moving all global variable settings into |
| # the given temporary module and erasing them here. |
| # |
| rule prepare-test ( temp-module ) |
| { |
| DELETE_MODULE $(temp-module) ; |
| |
| # Transfer globals to temp-module. |
| for local v in [ VARNAMES feature ] |
| { |
| if [ MATCH (\\.) : $(v) ] |
| { |
| modules.poke $(temp-module) : $(v) : $($(v)) ; |
| $(v) = ; |
| } |
| } |
| setup ; |
| } |
| |
| |
| # Clear out all global variables and recover all variables from the given |
| # temporary module. |
| # |
| rule finish-test ( temp-module ) |
| { |
| # Clear globals. |
| for local v in [ VARNAMES feature ] |
| { |
| if [ MATCH (\\.) : $(v) ] |
| { |
| $(v) = ; |
| } |
| } |
| |
| for local v in [ VARNAMES $(temp-module) ] |
| { |
| $(v) = [ modules.peek $(temp-module) : $(v) ] ; |
| } |
| DELETE_MODULE $(temp-module) ; |
| } |
| |
| |
| # Transform features by bracketing any elements which are not already bracketed |
| # by "<>". |
| # |
| local rule grist ( features * ) |
| { |
| local empty = "" ; |
| return $(empty:G=$(features)) ; |
| } |
| |
| |
| # Declare a new feature with the given name, values, and attributes. |
| # |
| rule feature ( |
| name # Feature name. |
| : values * # Allowable values - may be extended later using feature.extend. |
| : attributes * # Feature attributes (e.g. implicit, free, propagated...). |
| ) |
| { |
| name = [ grist $(name) ] ; |
| |
| local error ; |
| |
| # Check for any unknown attributes. |
| if ! ( $(attributes) in $(.all-attributes) ) |
| { |
| error = unknown attributes: |
| [ set.difference $(attributes) : $(.all-attributes) ] ; |
| } |
| else if $(name) in $(.all-features) |
| { |
| error = feature already defined: ; |
| } |
| else if implicit in $(attributes) && free in $(attributes) |
| { |
| error = free features cannot also be implicit ; |
| } |
| else if free in $(attributes) && propagated in $(attributes) |
| { |
| error = free features cannot be propagated ; |
| } |
| else |
| { |
| local m = [ MATCH (.*=.*) : $(values) ] ; |
| if $(m[1]) |
| { |
| error = "feature value may not contain '='" ; |
| } |
| } |
| |
| if $(error) |
| { |
| errors.error $(error) |
| : "in" feature declaration: |
| : feature [ lol->list $(1) : $(2) : $(3) ] ; |
| } |
| |
| $(name).values ?= ; |
| $(name).attributes = $(attributes) ; |
| $(name).subfeatures ?= ; |
| $(attributes).features += $(name) ; |
| |
| .all-features += $(name) ; |
| if subfeature in $(attributes) |
| { |
| .all-subfeatures += $(name) ; |
| } |
| else |
| { |
| .all-top-features += $(name) ; |
| } |
| extend $(name) : $(values) ; |
| } |
| |
| |
| # Sets the default value of the given feature, overriding any previous default. |
| # |
| rule set-default ( feature : value ) |
| { |
| local f = [ grist $(feature) ] ; |
| local a = $($(f).attributes) ; |
| local bad-attribute = ; |
| if free in $(a) |
| { |
| bad-attribute = free ; |
| } |
| else if optional in $(a) |
| { |
| bad-attribute = optional ; |
| } |
| if $(bad-attribute) |
| { |
| errors.error "$(bad-attribute) property $(f) cannot have a default." ; |
| } |
| if ! $(value) in $($(f).values) |
| { |
| errors.error "The specified default value, '$(value)' is invalid" |
| : "allowed values are: " $($(f).values) ; |
| } |
| $(f).default = $(value) ; |
| } |
| |
| |
| # Returns the default property values for the given features. |
| # |
| rule defaults ( features * ) |
| { |
| local result ; |
| for local f in $(features) |
| { |
| local gf = $(:E=:G=$(f)) ; |
| local a = $($(gf).attributes) ; |
| if ( free in $(a) ) || ( optional in $(a) ) |
| { |
| } |
| else |
| { |
| result += $(gf)$($(gf).default) ; |
| } |
| } |
| return $(result) ; |
| } |
| |
| |
| # Returns true iff all 'names' elements are valid features. |
| # |
| rule valid ( names + ) |
| { |
| if $(names) in $(.all-features) |
| { |
| return true ; |
| } |
| } |
| |
| |
| # Returns the attibutes of the given feature. |
| # |
| rule attributes ( feature ) |
| { |
| return $($(:E=:G=$(feature)).attributes) ; |
| } |
| |
| |
| # Returns the values of the given feature. |
| # |
| rule values ( feature ) |
| { |
| return $($(:E=:G=$(feature)).values) ; |
| } |
| |
| |
| # Returns true iff 'value-string' is a value-string of an implicit feature. |
| # |
| rule is-implicit-value ( value-string ) |
| { |
| local v = [ regex.split $(value-string) - ] ; |
| local failed ; |
| if ! $(v[1]) in $(.all-implicit-values) |
| { |
| failed = true ; |
| } |
| else |
| { |
| local feature = $($(v[1]).implicit-feature) ; |
| for local subvalue in $(v[2-]) |
| { |
| if ! [ find-implied-subfeature $(feature) $(subvalue) : $(v[1]) ] |
| { |
| failed = true ; |
| } |
| } |
| } |
| |
| if ! $(failed) |
| { |
| return true ; |
| } |
| } |
| |
| |
| # Returns the implicit feature associated with the given implicit value. |
| # |
| rule implied-feature ( implicit-value ) |
| { |
| local components = [ regex.split $(implicit-value) "-" ] ; |
| |
| local feature = $($(components[1]).implicit-feature) ; |
| if ! $(feature) |
| { |
| errors.error \"$(implicit-value)\" is not a value of an implicit feature ; |
| feature = "" ; # Keep testing happy; it expects a result. |
| } |
| return $(feature) ; |
| } |
| |
| |
| local rule find-implied-subfeature ( feature subvalue : value-string ? ) |
| { |
| # Feature should be of the form <feature-name>. |
| if $(feature) != $(feature:G) |
| { |
| errors.error invalid feature $(feature) ; |
| } |
| |
| return $($(feature)$(value-string:E="")<>$(subvalue).subfeature) ; |
| } |
| |
| |
| # Given a feature and a value of one of its subfeatures, find the name of the |
| # subfeature. If value-string is supplied, looks for implied subfeatures that |
| # are specific to that value of feature |
| # |
| rule implied-subfeature ( |
| feature # The main feature name. |
| subvalue # The value of one of its subfeatures. |
| : value-string ? # The value of the main feature. |
| ) |
| { |
| local subfeature = [ find-implied-subfeature $(feature) $(subvalue) |
| : $(value-string) ] ; |
| if ! $(subfeature) |
| { |
| value-string ?= "" ; |
| errors.error \"$(subvalue)\" is not a known subfeature value of |
| $(feature)$(value-string) ; |
| } |
| return $(subfeature) ; |
| } |
| |
| |
| # Generate an error if the feature is unknown. |
| # |
| local rule validate-feature ( feature ) |
| { |
| if ! $(feature) in $(.all-features) |
| { |
| errors.error unknown feature \"$(feature)\" ; |
| } |
| } |
| |
| |
| # Given a feature and its value or just a value corresponding to an implicit |
| # feature, returns a property set consisting of all component subfeatures and |
| # their values. For example all the following calls: |
| # |
| # expand-subfeatures-aux <toolset>gcc-2.95.2-linux-x86 |
| # expand-subfeatures-aux gcc-2.95.2-linux-x86 |
| # |
| # return: |
| # |
| # <toolset>gcc <toolset-version>2.95.2 <toolset-os>linux <toolset-cpu>x86 |
| # |
| local rule expand-subfeatures-aux ( |
| feature ? # Feature name or empty if value corresponds to an |
| # implicit property. |
| : value # Feature value. |
| : dont-validate ? # If set, no value string validation will be done. |
| ) |
| { |
| if $(feature) |
| { |
| feature = $(feature) ; |
| } |
| |
| if ! $(feature) |
| { |
| feature = [ implied-feature $(value) ] ; |
| } |
| else |
| { |
| validate-feature $(feature) ; |
| } |
| if ! $(dont-validate) |
| { |
| validate-value-string $(feature) $(value) ; |
| } |
| |
| local components = [ regex.split $(value) "-" ] ; |
| |
| # Get the top-level feature's value. |
| local value = $(components[1]:G=) ; |
| |
| local result = $(components[1]:G=$(feature)) ; |
| |
| local subvalues = $(components[2-]) ; |
| while $(subvalues) |
| { |
| local subvalue = $(subvalues[1]) ; # Pop the head off of subvalues. |
| subvalues = $(subvalues[2-]) ; |
| |
| local subfeature = [ find-implied-subfeature $(feature) $(subvalue) : |
| $(value) ] ; |
| |
| # If no subfeature was found reconstitute the value string and use that. |
| if ! $(subfeature) |
| { |
| result = $(components:J=-) ; |
| result = $(result:G=$(feature)) ; |
| subvalues = ; # Stop looping. |
| } |
| else |
| { |
| local f = [ MATCH ^<(.*)>$ : $(feature) ] ; |
| result += $(subvalue:G=$(f)-$(subfeature)) ; |
| } |
| } |
| |
| return $(result) ; |
| } |
| |
| |
| # Make all elements of properties corresponding to implicit features explicit, |
| # and express all subfeature values as separate properties in their own right. |
| # For example, all of the following properties |
| # |
| # gcc-2.95.2-linux-x86 |
| # <toolset>gcc-2.95.2-linux-x86 |
| # |
| # might expand to |
| # |
| # <toolset>gcc <toolset-version>2.95.2 <toolset-os>linux <toolset-cpu>x86 |
| # |
| rule expand-subfeatures ( |
| properties * # Property set with elements of the form |
| # <feature>value-string or just value-string in the case |
| # of implicit features. |
| : dont-validate ? |
| ) |
| { |
| local result ; |
| for local p in $(properties) |
| { |
| # Don't expand subfeatures in subfeatures |
| if ! [ MATCH "(:)" : $(p:G) ] |
| { |
| result += [ expand-subfeatures-aux $(p:G) : $(p:G=) : $(dont-validate) ] ; |
| } |
| else |
| { |
| result += $(p) ; |
| } |
| } |
| return $(result) ; |
| } |
| |
| |
| # Helper for extend, below. Handles the feature case. |
| # |
| local rule extend-feature ( feature : values * ) |
| { |
| feature = [ grist $(feature) ] ; |
| validate-feature $(feature) ; |
| if implicit in $($(feature).attributes) |
| { |
| for local v in $(values) |
| { |
| if $($(v).implicit-feature) |
| { |
| errors.error $(v) is already associated with the \"$($(v).implicit-feature)\" feature ; |
| } |
| $(v).implicit-feature = $(feature) ; |
| } |
| |
| .all-implicit-values += $(values) ; |
| } |
| if ! $($(feature).values) |
| { |
| # This is the first value specified for this feature so make it be the |
| # default. |
| $(feature).default = $(values[1]) ; |
| } |
| $(feature).values += $(values) ; |
| } |
| |
| |
| # Checks that value-string is a valid value-string for the given feature. |
| # |
| rule validate-value-string ( feature value-string ) |
| { |
| if ! ( |
| free in $($(feature).attributes) |
| || ( $(value-string) in $(feature).values ) |
| ) |
| { |
| local values = $(value-string) ; |
| |
| if $($(feature).subfeatures) |
| { |
| if ! ( $(value-string) in $($(feature).values) ) |
| && ! ( $(value-string) in $($(feature).subfeatures) ) |
| { |
| values = [ regex.split $(value-string) - ] ; |
| } |
| } |
| |
| if ! ( $(values[1]) in $($(feature).values) ) && |
| |
| # An empty value is allowed for optional features. |
| ( $(values[1]) || ! ( optional in $($(feature).attributes) ) ) |
| { |
| errors.error \"$(values[1])\" is not a known value of feature $(feature) |
| : legal values: \"$($(feature).values)\" ; |
| } |
| |
| for local v in $(values[2-]) |
| { |
| # This will validate any subfeature values in value-string. |
| implied-subfeature $(feature) $(v) : $(values[1]) ; |
| } |
| } |
| } |
| |
| |
| # A helper that computes: |
| # * name(s) of module-local variable(s) used to record the correspondence |
| # between subvalue(s) and a subfeature |
| # * value of that variable when such a subfeature/subvalue has been defined and |
| # returns a list consisting of the latter followed by the former. |
| # |
| local rule subvalue-var ( |
| feature # Main feature name. |
| value-string ? # If supplied, specifies a specific value of the main |
| # feature for which the subfeature values are valid. |
| : subfeature # Subfeature name. |
| : subvalues * # Subfeature values. |
| ) |
| { |
| feature = [ grist $(feature) ] ; |
| validate-feature $(feature) ; |
| if $(value-string) |
| { |
| validate-value-string $(feature) $(value-string) ; |
| } |
| |
| local subfeature-name = [ get-subfeature-name $(subfeature) $(value-string) ] ; |
| |
| return $(subfeature-name) |
| $(feature)$(value-string:E="")<>$(subvalues).subfeature ; |
| } |
| |
| |
| # Extends the given subfeature with the subvalues. If the optional value-string |
| # is provided, the subvalues are only valid for the given value of the feature. |
| # Thus, you could say that <target-platform>mingw is specific to |
| # <toolset>gcc-2.95.2 as follows: |
| # |
| # extend-subfeature toolset gcc-2.95.2 : target-platform : mingw ; |
| # |
| rule extend-subfeature ( |
| feature # The feature whose subfeature is being extended. |
| |
| value-string ? # If supplied, specifies a specific value of the main |
| # feature for which the new subfeature values are valid. |
| |
| : subfeature # Subfeature name. |
| : subvalues * # Additional subfeature values. |
| ) |
| { |
| local subfeature-vars = [ subvalue-var $(feature) $(value-string) |
| : $(subfeature) : $(subvalues) ] ; |
| |
| local f = [ utility.ungrist [ grist $(feature) ] ] ; |
| extend $(f)-$(subfeature-vars[1]) : $(subvalues) ; |
| |
| # Provide a way to get from the given feature or property and subfeature |
| # value to the subfeature name. |
| $(subfeature-vars[2-]) = $(subfeature-vars[1]) ; |
| } |
| |
| |
| # Returns true iff the subvalues are valid for the feature. When the optional |
| # value-string is provided, returns true iff the subvalues are valid for the |
| # given value of the feature. |
| # |
| rule is-subvalue ( feature : value-string ? : subfeature : subvalue ) |
| { |
| local subfeature-vars = [ subvalue-var $(feature) $(value-string) |
| : $(subfeature) : $(subvalue) ] ; |
| |
| if $($(subfeature-vars[2])) = $(subfeature-vars[1]) |
| { |
| return true ; |
| } |
| } |
| |
| |
| # Can be called three ways: |
| # |
| # 1. extend feature : values * |
| # 2. extend <feature> subfeature : values * |
| # 3. extend <feature>value-string subfeature : values * |
| # |
| # * Form 1 adds the given values to the given feature. |
| # * Forms 2 and 3 add subfeature values to the given feature. |
| # * Form 3 adds the subfeature values as specific to the given property |
| # value-string. |
| # |
| rule extend ( feature-or-property subfeature ? : values * ) |
| { |
| local feature ; # If a property was specified this is its feature. |
| local value-string ; # E.g., the gcc-2.95-2 part of <toolset>gcc-2.95.2. |
| |
| # If a property was specified. |
| if $(feature-or-property:G) && $(feature-or-property:G=) |
| { |
| # Extract the feature and value-string, if any. |
| feature = $(feature-or-property:G) ; |
| value-string = $(feature-or-property:G=) ; |
| } |
| else |
| { |
| feature = [ grist $(feature-or-property) ] ; |
| } |
| |
| # Dispatch to the appropriate handler. |
| if $(subfeature) |
| { |
| extend-subfeature $(feature) $(value-string) : $(subfeature) |
| : $(values) ; |
| } |
| else |
| { |
| # If no subfeature was specified, we do not expect to see a |
| # value-string. |
| if $(value-string) |
| { |
| errors.error can only specify a property as the first argument when |
| extending a subfeature |
| : usage: |
| : " extend" feature ":" values... |
| : " | extend" <feature>value-string subfeature ":" values... |
| ; |
| } |
| |
| extend-feature $(feature) : $(values) ; |
| } |
| } |
| |
| |
| local rule get-subfeature-name ( subfeature value-string ? ) |
| { |
| local prefix = $(value-string): ; |
| return $(prefix:E="")$(subfeature) ; |
| } |
| |
| |
| # Declares a subfeature. |
| # |
| rule subfeature ( |
| feature # Root feature that is not a subfeature. |
| value-string ? # A value-string specifying which feature or subfeature |
| # values this subfeature is specific to, if any. |
| : subfeature # The name of the subfeature being declared. |
| : subvalues * # The allowed values of this subfeature. |
| : attributes * # The attributes of the subfeature. |
| ) |
| { |
| feature = [ grist $(feature) ] ; |
| validate-feature $(feature) ; |
| |
| # Add grist to the subfeature name if a value-string was supplied. |
| local subfeature-name = [ get-subfeature-name $(subfeature) $(value-string) ] ; |
| |
| if $(subfeature-name) in $($(feature).subfeatures) |
| { |
| errors.error \"$(subfeature)\" already declared as a subfeature of \"$(feature)\" |
| "specific to "$(value-string) ; |
| } |
| $(feature).subfeatures += $(subfeature-name) ; |
| |
| # First declare the subfeature as a feature in its own right. |
| local f = [ utility.ungrist $(feature) ] ; |
| feature $(f)-$(subfeature-name) : $(subvalues) : $(attributes) subfeature ; |
| |
| # Now make sure the subfeature values are known. |
| extend-subfeature $(feature) $(value-string) : $(subfeature) : $(subvalues) ; |
| } |
| |
| |
| # Set components of the given composite property. |
| # |
| rule compose ( composite-property : component-properties * ) |
| { |
| local feature = $(composite-property:G) ; |
| if ! ( composite in [ attributes $(feature) ] ) |
| { |
| errors.error "$(feature)" is not a composite feature ; |
| } |
| |
| $(composite-property).components ?= ; |
| if $($(composite-property).components) |
| { |
| errors.error components of "$(composite-property)" already set: |
| $($(composite-property).components) ; |
| } |
| |
| if $(composite-property) in $(component-properties) |
| { |
| errors.error composite property "$(composite-property)" cannot have itself as a component ; |
| } |
| $(composite-property).components = $(component-properties) ; |
| } |
| |
| |
| local rule expand-composite ( property ) |
| { |
| return $(property) |
| [ sequence.transform expand-composite : $($(property).components) ] ; |
| } |
| |
| |
| # Return all values of the given feature specified by the given property set. |
| # |
| rule get-values ( feature : properties * ) |
| { |
| local result ; |
| |
| feature = $(:E=:G=$(feature)) ; # Add <> if necessary. |
| for local p in $(properties) |
| { |
| if $(p:G) = $(feature) |
| { |
| # Use MATCH instead of :G= to get the value, in order to preserve |
| # the value intact instead of having bjam treat it as a decomposable |
| # path. |
| result += [ MATCH ">(.*)" : $(p) ] ; |
| } |
| } |
| return $(result) ; |
| } |
| |
| |
| rule free-features ( ) |
| { |
| return $(free.features) ; |
| } |
| |
| |
| # Expand all composite properties in the set so that all components are |
| # explicitly expressed. |
| # |
| rule expand-composites ( properties * ) |
| { |
| local explicit-features = $(properties:G) ; |
| local result ; |
| |
| # Now expand composite features. |
| for local p in $(properties) |
| { |
| local expanded = [ expand-composite $(p) ] ; |
| |
| for local x in $(expanded) |
| { |
| if ! $(x) in $(result) |
| { |
| local f = $(x:G) ; |
| |
| if $(f) in $(free.features) |
| { |
| result += $(x) ; |
| } |
| else if ! $(x) in $(properties) # x is the result of expansion |
| { |
| if ! $(f) in $(explicit-features) # not explicitly-specified |
| { |
| if $(f) in $(result:G) |
| { |
| errors.error expansions of composite features result |
| in conflicting values for $(f) |
| : values: [ get-values $(f) : $(result) ] $(x:G=) |
| : one contributing composite property was $(p) ; |
| } |
| else |
| { |
| result += $(x) ; |
| } |
| } |
| } |
| else if $(f) in $(result:G) |
| { |
| errors.error explicitly-specified values of non-free feature |
| $(f) conflict : |
| "existing values:" [ get-values $(f) : $(properties) ] : |
| "value from expanding " $(p) ":" $(x:G=) ; |
| } |
| else |
| { |
| result += $(x) ; |
| } |
| } |
| } |
| } |
| return $(result) ; |
| } |
| |
| |
| # 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. |
| # |
| local rule is-subfeature-of ( parent-property f ) |
| { |
| if subfeature in $($(f).attributes) |
| { |
| local specific-subfeature = [ MATCH <(.*):(.*)> : $(f) ] ; |
| if $(specific-subfeature) |
| { |
| # The feature has the form <topfeature-topvalue:subfeature>, e.g. |
| # <toolset-msvc:version>. |
| local feature-value = [ split-top-feature $(specific-subfeature[1]) |
| ] ; |
| if <$(feature-value[1])>$(feature-value[2]) = $(parent-property) |
| { |
| return true ; |
| } |
| } |
| else |
| { |
| # The feature has the form <topfeature-subfeature>, e.g. |
| # <toolset-version> |
| local top-sub = [ split-top-feature [ utility.ungrist $(f) ] ] ; |
| if $(top-sub[2]) && <$(top-sub[1])> = $(parent-property:G) |
| { |
| return true ; |
| } |
| } |
| } |
| } |
| |
| |
| # As for is-subfeature-of but for subproperties. |
| # |
| local rule is-subproperty-of ( parent-property p ) |
| { |
| return [ is-subfeature-of $(parent-property) $(p:G) ] ; |
| } |
| |
| |
| # Given a property, return the subset of features consisting of all ordinary |
| # subfeatures of the property's feature, and all specific subfeatures of the |
| # property's feature which are conditional on the property's value. |
| # |
| local rule select-subfeatures ( parent-property : features * ) |
| { |
| return [ sequence.filter is-subfeature-of $(parent-property) : $(features) ] ; |
| } |
| |
| |
| # As for select-subfeatures but for subproperties. |
| # |
| local rule select-subproperties ( parent-property : properties * ) |
| { |
| return [ sequence.filter is-subproperty-of $(parent-property) : $(properties) ] ; |
| } |
| |
| |
| # Given a property set which may consist of composite and implicit properties |
| # and combined subfeature values, returns an expanded, normalized property set |
| # with all implicit features expressed explicitly, all subfeature values |
| # individually expressed, and all components of composite properties expanded. |
| # Non-free features directly expressed in the input properties cause any values |
| # of those features due to composite feature expansion to be dropped. If two |
| # values of a given non-free feature are directly expressed in the input, an |
| # error is issued. |
| # |
| rule expand ( properties * ) |
| { |
| local expanded = [ expand-subfeatures $(properties) ] ; |
| return [ expand-composites $(expanded) ] ; |
| } |
| |
| |
| # Helper rule for minimize. Returns true iff property's feature is present in |
| # the contents of the variable named by feature-set-var. |
| # |
| local rule in-features ( feature-set-var property ) |
| { |
| if $(property:G) in $($(feature-set-var)) |
| { |
| return true ; |
| } |
| } |
| |
| |
| # Helper rule for minimize. Returns the list with the same properties, but with |
| # all subfeatures moved to the end of the list. |
| # |
| local rule move-subfeatures-to-the-end ( properties * ) |
| { |
| local x1 ; |
| local x2 ; |
| for local p in $(properties) |
| { |
| if subfeature in $($(p:G).attributes) |
| { |
| x2 += $(p) ; |
| } |
| else |
| { |
| x1 += $(p) ; |
| } |
| } |
| return $(x1) $(x2) ; |
| } |
| |
| |
| # Given an expanded property set, eliminate all redundancy: properties that are |
| # elements of other (composite) properties in the set will be eliminated. |
| # Non-symmetric properties equal to default values will be eliminated unless |
| # they 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. |
| # |
| rule minimize ( properties * ) |
| { |
| # Precondition checking |
| local implicits = [ set.intersection $(p:G=) : $(p:G) ] ; |
| if $(implicits) |
| { |
| errors.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. |
| local components = $($(properties).components) ; |
| local x = [ set.difference $(properties) : $(components) ] ; |
| |
| # Handle subfeatures and implicit features. |
| x = [ move-subfeatures-to-the-end $(x) ] ; |
| local result ; |
| while $(x) |
| { |
| local p fullp = $(x[1]) ; |
| local f = $(p:G) ; |
| local v = $(p:G=) ; |
| |
| # Eliminate features in implicit properties. |
| if implicit in [ attributes $(f) ] |
| { |
| p = $(v) ; |
| } |
| |
| # Locate all subproperties of $(x[1]) in the property set. |
| local subproperties = [ select-subproperties $(fullp) : $(x) ] ; |
| if $(subproperties) |
| { |
| # Reconstitute the joined property name. |
| local sorted = [ sequence.insertion-sort $(subproperties) ] ; |
| result += $(p)-$(sorted:G="":J=-) ; |
| |
| x = [ set.difference $(x[2-]) : $(subproperties) ] ; |
| } |
| else |
| { |
| # Eliminate properties whose value is equal to feature's default, |
| # 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) ] |
| || symmetric in [ attributes $(f) ] |
| || $(fullp:G) in $(components:G) |
| { |
| result += $(p) ; |
| } |
| |
| x = $(x[2-]) ; |
| } |
| } |
| return $(result) ; |
| } |
| |
| |
| # Combine all subproperties into their parent properties |
| # |
| # Requires: for every subproperty, there is a parent property. All features are |
| # explicitly expressed. |
| # |
| # This rule probably should not be needed, but build-request.expand-no-defaults |
| # is being abused for unintended purposes and it needs help. |
| # |
| rule compress-subproperties ( properties * ) |
| { |
| local all-subs ; |
| local matched-subs ; |
| local result ; |
| |
| for local p in $(properties) |
| { |
| if ! $(p:G) |
| { |
| # Expecting fully-gristed properties. |
| assert.variable-not-empty p:G ; |
| } |
| |
| if ! subfeature in $($(p:G).attributes) |
| { |
| local subs = [ sequence.insertion-sort |
| [ sequence.filter is-subproperty-of $(p) : $(properties) ] ] ; |
| |
| matched-subs += $(subs) ; |
| |
| local subvalues = -$(subs:G=:J=-) ; |
| subvalues ?= "" ; |
| result += $(p)$(subvalues) ; |
| } |
| else |
| { |
| all-subs += $(p) ; |
| } |
| } |
| assert.result true : set.equal $(all-subs) : $(matched-subs) ; |
| return $(result) ; |
| } |
| |
| |
| # Given an ungristed string, finds the longest prefix which is a top-level |
| # feature name followed by a dash, and return a pair consisting of the parts |
| # before and after that dash. More interesting than a simple split because |
| # feature names may contain dashes. |
| # |
| local rule split-top-feature ( feature-plus ) |
| { |
| local e = [ regex.split $(feature-plus) - ] ; |
| local f = $(e[1]) ; |
| local v ; |
| while $(e) |
| { |
| if <$(f)> in $(.all-top-features) |
| { |
| v = $(f) $(e[2-]:J=-) ; |
| } |
| e = $(e[2-]) ; |
| f = $(f)-$(e[1]) ; |
| } |
| return $(v) ; |
| } |
| |
| |
| # Given a set of properties, add default values for features not represented in |
| # the set. |
| # |
| # Note: if there's an ordinary feature F1 and a composite feature F2 which |
| # includes some value for F1 and both feature have default values then the |
| # default value of F1 will be added (as opposed to the value in F2). This might |
| # not be the right idea, e.g. 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. |
| # |
| rule add-defaults ( properties * ) |
| { |
| for local v in $(properties:G=) |
| { |
| if $(v) in $(properties) |
| { |
| errors.error add-defaults requires explicitly specified features, |
| but \"$(v)\" appears to be the value of an un-expanded implicit |
| feature ; |
| } |
| } |
| # 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. |
| local xproperties = [ MATCH "^([^:]+)$" : $(properties) ] ; |
| local missing-top = [ set.difference $(.all-top-features) : $(xproperties:G) ] ; |
| local more = [ defaults $(missing-top) ] ; |
| properties += $(more) ; |
| xproperties += $(more) ; |
| |
| # Add defaults for subfeatures of features which are present. |
| for local p in $(xproperties) |
| { |
| local s = $($(p:G).subfeatures) ; |
| local f = [ utility.ungrist $(p:G) ] ; |
| local missing-subs = [ set.difference <$(f)-$(s)> : $(properties:G) ] ; |
| properties += [ defaults [ select-subfeatures $(p) : $(missing-subs) ] ] ; |
| } |
| |
| return $(properties) ; |
| } |
| |
| |
| # Given a property-set of the form |
| # v1/v2/...vN-1/<fN>vN/<fN+1>vN+1/...<fM>vM |
| # |
| # Returns |
| # v1 v2 ... vN-1 <fN>vN <fN+1>vN+1 ... <fM>vM |
| # |
| # Note that vN...vM may contain slashes. This needs to be resilient to the |
| # substitution of backslashes for slashes, since Jam, unbidden, sometimes swaps |
| # slash direction on NT. |
| # |
| rule split ( property-set ) |
| { |
| local pieces = [ regex.split $(property-set) [\\/] ] ; |
| local result ; |
| |
| for local x in $(pieces) |
| { |
| if ( ! $(x:G) ) && $(result[-1]:G) |
| { |
| result = $(result[1--2]) $(result[-1])/$(x) ; |
| } |
| else |
| { |
| result += $(x) ; |
| } |
| } |
| |
| return $(result) ; |
| } |
| |
| |
| # Tests of module feature. |
| # |
| rule __test__ ( ) |
| { |
| # Use a fresh copy of the feature module. |
| prepare-test feature-test-temp ; |
| |
| import assert ; |
| import errors : try catch ; |
| |
| # These are local rules and so must be explicitly reimported into the |
| # testing module. |
| import feature : extend-feature validate-feature select-subfeatures ; |
| |
| feature toolset : gcc : implicit ; |
| feature define : : free ; |
| feature runtime-link : dynamic static : symmetric ; |
| feature optimization : on off ; |
| feature variant : debug release profile : implicit composite symmetric ; |
| feature stdlib : native stlport ; |
| feature magic : : free ; |
| |
| compose <variant>debug : <define>_DEBUG <optimization>off ; |
| compose <variant>release : <define>NDEBUG <optimization>on ; |
| |
| assert.result dynamic static : values <runtime-link> ; |
| assert.result dynamic static : values runtime-link ; |
| |
| try ; |
| { |
| compose <variant>profile : <variant>profile ; |
| } |
| catch composite property <variant>profile cannot have itself as a component ; |
| |
| extend-feature toolset : msvc metrowerks ; |
| subfeature toolset gcc : version : 2.95.2 2.95.3 2.95.4 3.0 3.0.1 3.0.2 ; |
| |
| assert.true is-subvalue toolset : gcc : version : 2.95.3 ; |
| assert.false is-subvalue toolset : gcc : version : 1.1 ; |
| |
| assert.false is-subvalue toolset : msvc : version : 2.95.3 ; |
| assert.false is-subvalue toolset : : version : yabba ; |
| |
| feature yabba ; |
| subfeature yabba : version : dabba ; |
| assert.true is-subvalue yabba : : version : dabba ; |
| |
| subfeature toolset gcc : platform : linux cygwin : optional ; |
| |
| assert.result <toolset-gcc:version> |
| : select-subfeatures <toolset>gcc |
| : <toolset-gcc:version> |
| <toolset-msvc:version> |
| <toolset-version> |
| <stdlib> ; |
| |
| subfeature stdlib : version : 3 4 : optional ; |
| |
| assert.result <stdlib-version> |
| : select-subfeatures <stdlib>native |
| : <toolset-gcc:version> |
| <toolset-msvc:version> |
| <toolset-version> |
| <stdlib-version> ; |
| |
| assert.result <toolset>gcc <toolset-gcc:version>3.0.1 |
| : expand-subfeatures <toolset>gcc-3.0.1 ; |
| |
| assert.result <toolset>gcc <toolset-gcc:version>3.0.1 <toolset-gcc:platform>linux |
| : expand-subfeatures <toolset>gcc-3.0.1-linux ; |
| |
| assert.result <toolset>gcc <toolset-gcc:version>3.0.1 |
| : expand <toolset>gcc <toolset-gcc:version>3.0.1 ; |
| |
| assert.result <define>foo=x-y |
| : expand-subfeatures <define>foo=x-y ; |
| |
| assert.result <toolset>gcc <toolset-gcc:version>3.0.1 |
| : expand-subfeatures gcc-3.0.1 ; |
| |
| assert.result a c e |
| : get-values <x> : <x>a <y>b <x>c <y>d <x>e ; |
| |
| assert.result <toolset>gcc <toolset-gcc:version>3.0.1 |
| <variant>debug <define>_DEBUG <optimization>on |
| : expand gcc-3.0.1 debug <optimization>on ; |
| |
| assert.result <variant>debug <define>_DEBUG <optimization>on |
| : expand debug <optimization>on ; |
| |
| assert.result <optimization>on <variant>debug <define>_DEBUG |
| : expand <optimization>on debug ; |
| |
| assert.result <runtime-link>dynamic <optimization>on |
| : defaults <runtime-link> <define> <optimization> ; |
| |
| # Make sure defaults is resilient to missing grist. |
| assert.result <runtime-link>dynamic <optimization>on |
| : defaults runtime-link define optimization ; |
| |
| feature dummy : dummy1 dummy2 ; |
| subfeature dummy : subdummy : x y z : optional ; |
| |
| feature fu : fu1 fu2 : optional ; |
| subfeature fu : subfu : x y z : optional ; |
| subfeature fu : subfu2 : q r s ; |
| |
| assert.result optional : attributes <fu> ; |
| assert.result optional : attributes fu ; |
| |
| assert.result <runtime-link>static <define>foobar <optimization>on |
| <toolset>gcc:<define>FOO <toolset>gcc <variant>debug <stdlib>native |
| <dummy>dummy1 <toolset-gcc:version>2.95.2 |
| : add-defaults <runtime-link>static <define>foobar <optimization>on |
| <toolset>gcc:<define>FOO ; |
| |
| assert.result <runtime-link>static <define>foobar <optimization>on |
| <toolset>gcc:<define>FOO <fu>fu1 <toolset>gcc <variant>debug |
| <stdlib>native <dummy>dummy1 <fu-subfu2>q <toolset-gcc:version>2.95.2 |
| : add-defaults <runtime-link>static <define>foobar <optimization>on |
| <toolset>gcc:<define>FOO <fu>fu1 ; |
| |
| set-default <runtime-link> : static ; |
| assert.result <runtime-link>static : defaults <runtime-link> ; |
| |
| assert.result gcc-3.0.1 debug <optimization>on |
| : minimize [ expand gcc-3.0.1 debug <optimization>on <stdlib>native ] ; |
| |
| assert.result gcc-3.0.1 debug <runtime-link>dynamic |
| : minimize |
| [ expand gcc-3.0.1 debug <optimization>off <runtime-link>dynamic ] ; |
| |
| assert.result gcc-3.0.1 debug |
| : minimize [ expand gcc-3.0.1 debug <optimization>off ] ; |
| |
| assert.result debug <optimization>on |
| : minimize [ expand debug <optimization>on ] ; |
| |
| assert.result gcc-3.0 |
| : minimize <toolset>gcc <toolset-gcc:version>3.0 ; |
| |
| assert.result gcc-3.0 |
| : minimize <toolset-gcc:version>3.0 <toolset>gcc ; |
| |
| assert.result <x>y/z <a>b/c <d>e/f |
| : split <x>y/z/<a>b/c/<d>e/f ; |
| |
| assert.result <x>y/z <a>b/c <d>e/f |
| : split <x>y\\z\\<a>b\\c\\<d>e\\f ; |
| |
| assert.result a b c <d>e/f/g <h>i/j/k |
| : split a/b/c/<d>e/f/g/<h>i/j/k ; |
| |
| assert.result a b c <d>e/f/g <h>i/j/k |
| : split a\\b\\c\\<d>e\\f\\g\\<h>i\\j\\k ; |
| |
| # Test error checking. |
| |
| try ; |
| { |
| expand release <optimization>off <optimization>on ; |
| } |
| catch explicitly-specified values of non-free feature <optimization> conflict ; |
| |
| try ; |
| { |
| validate-feature <foobar> ; |
| } |
| catch unknown feature ; |
| |
| validate-value-string <toolset> gcc ; |
| validate-value-string <toolset> gcc-3.0.1 ; |
| |
| try ; |
| { |
| validate-value-string <toolset> digital_mars ; |
| } |
| catch \"digital_mars\" is not a known value of <toolset> ; |
| |
| try ; |
| { |
| feature foobar : : baz ; |
| } |
| catch unknown attributes: baz ; |
| |
| feature feature1 ; |
| try ; |
| { |
| feature feature1 ; |
| } |
| catch feature already defined: ; |
| |
| try ; |
| { |
| feature feature2 : : free implicit ; |
| } |
| catch free features cannot also be implicit ; |
| |
| try ; |
| { |
| feature feature3 : : free propagated ; |
| } |
| catch free features cannot be propagated ; |
| |
| try ; |
| { |
| implied-feature lackluster ; |
| } |
| catch \"lackluster\" is not a value of an implicit feature ; |
| |
| try ; |
| { |
| implied-subfeature <toolset> 3.0.1 ; |
| } |
| catch \"3.0.1\" is not a known subfeature value of <toolset> ; |
| |
| try ; |
| { |
| implied-subfeature <toolset> not-a-version : gcc ; |
| } |
| catch \"not-a-version\" is not a known subfeature value of <toolset>gcc ; |
| |
| # Leave a clean copy of the features module behind. |
| finish-test feature-test-temp ; |
| } |
