diff options
Diffstat (limited to 'jam-files/boost-build/build')
34 files changed, 0 insertions, 19696 deletions
diff --git a/jam-files/boost-build/build/__init__.py b/jam-files/boost-build/build/__init__.py deleted file mode 100644 index e69de29b..00000000 --- a/jam-files/boost-build/build/__init__.py +++ /dev/null diff --git a/jam-files/boost-build/build/ac.jam b/jam-files/boost-build/build/ac.jam deleted file mode 100644 index 6768f358..00000000 --- a/jam-files/boost-build/build/ac.jam +++ /dev/null @@ -1,198 +0,0 @@ -# Copyright (c) 2010 Vladimir Prus. -# -# Use, modification and distribution is subject to the Boost Software -# License Version 1.0. (See accompanying file LICENSE_1_0.txt or -# http://www.boost.org/LICENSE_1_0.txt) - -import property-set ; -import path ; -import modules ; -import "class" ; -import errors ; -import configure ; - -rule find-include-path ( variable : properties : header - : provided-path ? ) -{ - # FIXME: document which properties affect this function by - # default. - local target-os = [ $(properties).get <target-os> ] ; - properties = [ property-set.create <target-os>$(toolset) ] ; - if $($(variable)-$(properties)) - { - return $($(variable)-$(properties)) ; - } - else - { - provided-path ?= [ modules.peek : $(variable) ] ; - includes = $(provided-path) ; - includes += [ $(properties).get <include> ] ; - if [ $(properties).get <target-os> ] != windows - { - # FIXME: use sysroot - includes += /usr/include ; - } - - local result ; - while ! $(result) && $(includes) - { - local f = [ path.root $(header) $(includes[1]) ] ; - ECHO "Checking " $(f) ; - if [ path.exists $(f) ] - { - result = $(includes[1]) ; - } - else if $(provided-path) - { - errors.user-error "Could not find header" $(header) - : "in the user-specified directory" $(provided-path) ; - } - includes = $(includes[2-]) ; - } - $(variable)-$(properties) = $(result) ; - return $(result) ; - } -} - -rule find-library ( variable : properties : names + : provided-path ? ) -{ - local target-os = [ $(properties).get <target-os> ] ; - properties = [ property-set.create <target-os>$(toolset) ] ; - if $($(variable)-$(properties)) - { - return $($(variable)-$(properties)) ; - } - else - { - provided-path ?= [ modules.peek : $(variable) ] ; - paths = $(provided-path) ; - paths += [ $(properties).get <library-path> ] ; - if [ $(properties).get <target-os> ] != windows - { - paths += /usr/lib /usr/lib32 /usr/lib64 ; - } - - local result ; - while ! $(result) && $(paths) - { - while ! $(result) && $(names) - { - local f ; - if $(target-os) = windows - { - f = $(paths[1])/$(names[1]).lib ; - if [ path.exists $(f) ] - { - result = $(f) ; - } - } - else - { - # FIXME: check for .a as well, depending on - # the 'link' feature. - f = $(paths[1])/lib$(names[1]).so ; - ECHO "CHECKING $(f) " ; - if [ path.exists $(f) ] - { - result = $(f) ; - } - } - if ! $(result) && $(provided-path) - { - errors.user-error "Could not find either of: " $(names) - : "in the user-specified directory" $(provided-path) ; - - } - names = $(names[2-]) ; - } - paths = $(paths[2-]) ; - } - $(variable)-$(properties) = $(result) ; - return $(result) ; - } -} - -class ac-library : basic-target -{ - import errors ; - import indirect ; - import virtual-target ; - import ac ; - import configure ; - - rule __init__ ( name : project : * : * ) - { - basic-target.__init__ $(name) : $(project) : $(sources) - : $(requirements) ; - - reconfigure $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ; - } - - rule set-header ( header ) - { - self.header = $(header) ; - } - - rule set-default-names ( names + ) - { - self.default-names = $(names) ; - } - - rule reconfigure ( * : * ) - { - ECHO "XXX" $(1) ; - if ! $(1) - { - # This is 'using xxx ;'. Nothing to configure, really. - } - else - { - for i in 1 2 3 4 5 6 7 8 9 - { - # FIXME: this naming is inconsistent with XXX_INCLUDE/XXX_LIBRARY - if ! ( $($(i)[1]) in root include-path library-path library-name condition ) - { - errors.user-error "Invalid named parameter" $($(i)[1]) ; - } - local name = $($(i)[1]) ; - local value = $($(i)[2-]) ; - if $($(name)) && $($(name)) != $(value) - { - errors.user-error "Attempt to change value of '$(name)'" ; - } - $(name) = $(value) ; - } - - include-path ?= $(root)/include ; - library-path ?= $(root)/lib ; - } - } - - rule construct ( name : sources * : property-set ) - { - # FIXME: log results. - local libnames = $(library-name) ; - if ! $(libnames) && ! $(include-path) && ! $(library-path) - { - libnames = [ modules.peek : $(name:U)_NAME ] ; - # Backward compatibility only. - libnames ?= [ modules.peek : $(name:U)_BINARY ] ; - } - libnames ?= $(self.default-names) ; - - local includes = [ - ac.find-include-path $(name:U)_INCLUDE : $(property-set) : $(self.header) : $(include-path) ] ; - local library = [ ac.find-library $(name:U)_LIBRARY : $(property-set) : $(libnames) : $(library-path) ] ; - if $(includes) && $(library) - { - library = [ virtual-target.from-file $(library) : . : $(self.project) ] ; - configure.log-library-search-result $(name) : "found" ; - return [ property-set.create <include>$(includes) <source>$(library) ] ; - } - else - { - configure.log-library-search-result $(name) : "no found" ; - } - } -} - diff --git a/jam-files/boost-build/build/alias.jam b/jam-files/boost-build/build/alias.jam deleted file mode 100644 index 48019cb9..00000000 --- a/jam-files/boost-build/build/alias.jam +++ /dev/null @@ -1,73 +0,0 @@ -# Copyright 2003, 2004, 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) - -# This module defines the 'alias' rule and the associated target class. -# -# Alias is just a main target which returns its source targets without any -# processing. For example: -# -# alias bin : hello test_hello ; -# alias lib : helpers xml_parser ; -# -# Another important use of 'alias' is to conveniently group source files: -# -# alias platform-src : win.cpp : <os>NT ; -# alias platform-src : linux.cpp : <os>LINUX ; -# exe main : main.cpp platform-src ; -# -# Lastly, it is possible to create a local alias for some target, with different -# properties: -# -# alias big_lib : : @/external_project/big_lib/<link>static ; -# - -import "class" : new ; -import project ; -import property-set ; -import targets ; - - -class alias-target-class : basic-target -{ - rule __init__ ( name : project : sources * : requirements * - : default-build * : usage-requirements * ) - { - basic-target.__init__ $(name) : $(project) : $(sources) : - $(requirements) : $(default-build) : $(usage-requirements) ; - } - - rule construct ( name : source-targets * : property-set ) - { - return [ property-set.empty ] $(source-targets) ; - } - - rule compute-usage-requirements ( subvariant ) - { - local base = [ basic-target.compute-usage-requirements $(subvariant) ] ; - return [ $(base).add [ $(subvariant).sources-usage-requirements ] ] ; - } -} - - -# Declares the 'alias' target. It will process its sources virtual-targets by -# returning them unaltered as its own constructed virtual-targets. -# -rule alias ( name : sources * : requirements * : default-build * : - usage-requirements * ) -{ - local project = [ project.current ] ; - - targets.main-target-alternative - [ new alias-target-class $(name) : $(project) - : [ targets.main-target-sources $(sources) : $(name) : no-renaming ] - : [ targets.main-target-requirements $(requirements) : $(project) ] - : [ targets.main-target-default-build $(default-build) : $(project) - ] - : [ targets.main-target-usage-requirements $(usage-requirements) : - $(project) ] - ] ; -} - - -IMPORT $(__name__) : alias : : alias ; diff --git a/jam-files/boost-build/build/alias.py b/jam-files/boost-build/build/alias.py deleted file mode 100644 index 575e5360..00000000 --- a/jam-files/boost-build/build/alias.py +++ /dev/null @@ -1,63 +0,0 @@ -# Copyright 2003, 2004, 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) - -# Status: ported (danielw) -# Base revision: 56043 - -# This module defines the 'alias' rule and associated class. -# -# Alias is just a main target which returns its source targets without any -# processing. For example:: -# -# alias bin : hello test_hello ; -# alias lib : helpers xml_parser ; -# -# Another important use of 'alias' is to conveniently group source files:: -# -# alias platform-src : win.cpp : <os>NT ; -# alias platform-src : linux.cpp : <os>LINUX ; -# exe main : main.cpp platform-src ; -# -# Lastly, it's possible to create local alias for some target, with different -# properties:: -# -# alias big_lib : : @/external_project/big_lib/<link>static ; -# - -import targets -import property_set -from b2.manager import get_manager - -from b2.util import metatarget - -class AliasTarget(targets.BasicTarget): - - def __init__(self, *args): - targets.BasicTarget.__init__(self, *args) - - def construct(self, name, source_targets, properties): - return [property_set.empty(), source_targets] - - def compute_usage_requirements(self, subvariant): - base = targets.BasicTarget.compute_usage_requirements(self, subvariant) - # Add source's usage requirement. If we don't do this, "alias" does not - # look like 100% alias. - return base.add(subvariant.sources_usage_requirements()) - -@metatarget -def alias(name, sources=[], requirements=[], default_build=[], usage_requirements=[]): - - project = get_manager().projects().current() - targets = get_manager().targets() - - targets.main_target_alternative(AliasTarget( - name, project, - targets.main_target_sources(sources, name, no_renaming=True), - targets.main_target_requirements(requirements or [], project), - targets.main_target_default_build(default_build, project), - targets.main_target_usage_requirements(usage_requirements or [], project))) - -# Declares the 'alias' target. It will build sources, and return them unaltered. -get_manager().projects().add_rule("alias", alias) - diff --git a/jam-files/boost-build/build/build-request.jam b/jam-files/boost-build/build/build-request.jam deleted file mode 100644 index 8a1f7b0e..00000000 --- a/jam-files/boost-build/build/build-request.jam +++ /dev/null @@ -1,322 +0,0 @@ -# Copyright 2002 Dave Abrahams -# 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 "class" : new ; -import sequence ; -import set ; -import regex ; -import feature ; -import property ; -import container ; -import string ; - - -# Transform property-set by applying f to each component property. -# -local rule apply-to-property-set ( f property-set ) -{ - local properties = [ feature.split $(property-set) ] ; - return [ string.join [ $(f) $(properties) ] : / ] ; -} - - -# Expand the given build request by combining all property-sets which do not -# specify conflicting non-free features. Expects all the project files to -# already be loaded. -# -rule expand-no-defaults ( property-sets * ) -{ - # First make all features and subfeatures explicit. - local expanded-property-sets = [ sequence.transform apply-to-property-set - feature.expand-subfeatures : $(property-sets) ] ; - - # Now combine all of the expanded property-sets - local product = [ x-product $(expanded-property-sets) : $(feature-space) ] ; - - return $(product) ; -} - - -# Implementation of x-product, below. Expects all the project files to already -# be loaded. -# -local rule x-product-aux ( property-sets + ) -{ - local result ; - local p = [ feature.split $(property-sets[1]) ] ; - local f = [ set.difference $(p:G) : [ feature.free-features ] ] ; - local seen ; - # No conflict with things used at a higher level? - if ! [ set.intersection $(f) : $(x-product-used) ] - { - local x-product-seen ; - { - # Do not mix in any conflicting features. - local x-product-used = $(x-product-used) $(f) ; - - if $(property-sets[2]) - { - local rest = [ x-product-aux $(property-sets[2-]) : $(feature-space) ] ; - result = $(property-sets[1])/$(rest) ; - } - - result ?= $(property-sets[1]) ; - } - - # If we did not encounter a conflicting feature lower down, do not - # recurse again. - if ! [ set.intersection $(f) : $(x-product-seen) ] - { - property-sets = ; - } - - seen = $(x-product-seen) ; - } - - if $(property-sets[2]) - { - result += [ x-product-aux $(property-sets[2-]) : $(feature-space) ] ; - } - - # Note that we have seen these features so that higher levels will recurse - # again without them set. - x-product-seen += $(f) $(seen) ; - return $(result) ; -} - - -# Return the cross-product of all elements of property-sets, less any that would -# contain conflicting values for single-valued features. Expects all the project -# files to already be loaded. -# -local rule x-product ( property-sets * ) -{ - if $(property-sets).non-empty - { - # Prepare some "scoped globals" that can be used by the implementation - # function, x-product-aux. - local x-product-seen x-product-used ; - return [ x-product-aux $(property-sets) : $(feature-space) ] ; - } - # Otherwise return empty. -} - - -# Returns true if either 'v' or the part of 'v' before the first '-' symbol is -# an implicit value. Expects all the project files to already be loaded. -# -local rule looks-like-implicit-value ( v ) -{ - if [ feature.is-implicit-value $(v) ] - { - return true ; - } - else - { - local split = [ regex.split $(v) - ] ; - if [ feature.is-implicit-value $(split[1]) ] - { - return true ; - } - } -} - - -# Takes the command line tokens (such as taken from the ARGV rule) and -# constructs a build request from them. Returns a vector of two vectors (where -# "vector" means container.jam's "vector"). First is the set of targets -# specified in the command line, and second is the set of requested build -# properties. Expects all the project files to already be loaded. -# -rule from-command-line ( command-line * ) -{ - local targets ; - local properties ; - - command-line = $(command-line[2-]) ; - local skip-next = ; - for local e in $(command-line) - { - if $(skip-next) - { - skip-next = ; - } - else if ! [ MATCH "^(-).*" : $(e) ] - { - # Build request spec either has "=" in it or completely consists of - # implicit feature values. - local fs = feature-space ; - if [ MATCH "(.*=.*)" : $(e) ] - || [ looks-like-implicit-value $(e:D=) : $(feature-space) ] - { - properties += [ convert-command-line-element $(e) : - $(feature-space) ] ; - } - else - { - targets += $(e) ; - } - } - else if [ MATCH "^(-[-ldjfsto])$" : $(e) ] - { - skip-next = true ; - } - } - return [ new vector - [ new vector $(targets) ] - [ new vector $(properties) ] ] ; -} - - -# Converts one element of command line build request specification into internal -# form. Expects all the project files to already be loaded. -# -local rule convert-command-line-element ( e ) -{ - local result ; - local parts = [ regex.split $(e) "/" ] ; - while $(parts) - { - local p = $(parts[1]) ; - local m = [ MATCH "([^=]*)=(.*)" : $(p) ] ; - local lresult ; - local feature ; - local values ; - if $(m) - { - feature = $(m[1]) ; - values = [ regex.split $(m[2]) "," ] ; - lresult = <$(feature)>$(values) ; - } - else - { - lresult = [ regex.split $(p) "," ] ; - } - - if $(feature) && free in [ feature.attributes $(feature) ] - { - # If we have free feature, then the value is everything - # until the end of the command line token. Slashes in - # the following string are not taked to mean separation - # of properties. Commas are also not interpreted specially. - values = $(values:J=,) ; - values = $(values) $(parts[2-]) ; - values = $(values:J=/) ; - lresult = <$(feature)>$(values) ; - parts = ; - } - - if ! [ MATCH (.*-.*) : $(p) ] - { - # property.validate cannot handle subfeatures, so we avoid the check - # here. - for local p in $(lresult) - { - property.validate $(p) : $(feature-space) ; - } - } - - if ! $(result) - { - result = $(lresult) ; - } - else - { - result = $(result)/$(lresult) ; - } - - parts = $(parts[2-]) ; - } - - return $(result) ; -} - - -rule __test__ ( ) -{ - import assert ; - import feature ; - - feature.prepare-test build-request-test-temp ; - - import build-request ; - import build-request : expand-no-defaults : build-request.expand-no-defaults ; - import errors : try catch ; - import feature : feature subfeature ; - - feature toolset : gcc msvc borland : implicit ; - subfeature toolset gcc : version : 2.95.2 2.95.3 2.95.4 - 3.0 3.0.1 3.0.2 : optional ; - - feature variant : debug release : implicit composite ; - feature inlining : on off ; - feature "include" : : free ; - - feature stdlib : native stlport : implicit ; - - feature runtime-link : dynamic static : symmetric ; - - # Empty build requests should expand to empty. - assert.result - : build-request.expand-no-defaults ; - - assert.result - <toolset>gcc/<toolset-gcc:version>3.0.1/<stdlib>stlport/<variant>debug - <toolset>msvc/<stdlib>stlport/<variant>debug - <toolset>msvc/<variant>debug - : build-request.expand-no-defaults gcc-3.0.1/stlport msvc/stlport msvc debug ; - - assert.result - <toolset>gcc/<toolset-gcc:version>3.0.1/<stdlib>stlport/<variant>debug - <toolset>msvc/<variant>debug - <variant>debug/<toolset>msvc/<stdlib>stlport - : build-request.expand-no-defaults gcc-3.0.1/stlport msvc debug msvc/stlport ; - - assert.result - <toolset>gcc/<toolset-gcc:version>3.0.1/<stdlib>stlport/<variant>debug/<inlining>off - <toolset>gcc/<toolset-gcc:version>3.0.1/<stdlib>stlport/<variant>release/<inlining>off - : build-request.expand-no-defaults gcc-3.0.1/stlport debug release <inlining>off ; - - assert.result - <include>a/b/c/<toolset>gcc/<toolset-gcc:version>3.0.1/<stdlib>stlport/<variant>debug/<include>x/y/z - <include>a/b/c/<toolset>msvc/<stdlib>stlport/<variant>debug/<include>x/y/z - <include>a/b/c/<toolset>msvc/<variant>debug/<include>x/y/z - : build-request.expand-no-defaults <include>a/b/c gcc-3.0.1/stlport msvc/stlport msvc debug <include>x/y/z ; - - local r ; - - r = [ build-request.from-command-line bjam debug runtime-link=dynamic ] ; - assert.equal [ $(r).get-at 1 ] : ; - assert.equal [ $(r).get-at 2 ] : debug <runtime-link>dynamic ; - - try ; - { - build-request.from-command-line bjam gcc/debug runtime-link=dynamic/static ; - } - catch \"static\" is not a value of an implicit feature ; - - r = [ build-request.from-command-line bjam -d2 --debug debug target runtime-link=dynamic ] ; - assert.equal [ $(r).get-at 1 ] : target ; - assert.equal [ $(r).get-at 2 ] : debug <runtime-link>dynamic ; - - r = [ build-request.from-command-line bjam debug runtime-link=dynamic,static ] ; - assert.equal [ $(r).get-at 1 ] : ; - assert.equal [ $(r).get-at 2 ] : debug <runtime-link>dynamic <runtime-link>static ; - - r = [ build-request.from-command-line bjam debug gcc/runtime-link=dynamic,static ] ; - assert.equal [ $(r).get-at 1 ] : ; - assert.equal [ $(r).get-at 2 ] : debug gcc/<runtime-link>dynamic - gcc/<runtime-link>static ; - - r = [ build-request.from-command-line bjam msvc gcc,borland/runtime-link=static ] ; - assert.equal [ $(r).get-at 1 ] : ; - assert.equal [ $(r).get-at 2 ] : msvc gcc/<runtime-link>static - borland/<runtime-link>static ; - - r = [ build-request.from-command-line bjam gcc-3.0 ] ; - assert.equal [ $(r).get-at 1 ] : ; - assert.equal [ $(r).get-at 2 ] : gcc-3.0 ; - - feature.finish-test build-request-test-temp ; -} diff --git a/jam-files/boost-build/build/build_request.py b/jam-files/boost-build/build/build_request.py deleted file mode 100644 index cc9f2400..00000000 --- a/jam-files/boost-build/build/build_request.py +++ /dev/null @@ -1,216 +0,0 @@ -# Status: being ported by Vladimir Prus -# TODO: need to re-compare with mainline of .jam -# Base revision: 40480 -# -# (C) Copyright David Abrahams 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. - -import b2.build.feature -feature = b2.build.feature - -from b2.util.utility import * -import b2.build.property_set as property_set - -def expand_no_defaults (property_sets): - """ Expand the given build request by combining all property_sets which don't - specify conflicting non-free features. - """ - # First make all features and subfeatures explicit - expanded_property_sets = [ps.expand_subfeatures() for ps in property_sets] - - # Now combine all of the expanded property_sets - product = __x_product (expanded_property_sets) - - return [property_set.create(p) for p in product] - - -def __x_product (property_sets): - """ Return the cross-product of all elements of property_sets, less any - that would contain conflicting values for single-valued features. - """ - x_product_seen = set() - return __x_product_aux (property_sets, x_product_seen)[0] - -def __x_product_aux (property_sets, seen_features): - """Returns non-conflicting combinations of property sets. - - property_sets is a list of PropertySet instances. seen_features is a set of Property - instances. - - Returns a tuple of: - - list of lists of Property instances, such that within each list, no two Property instance - have the same feature, and no Property is for feature in seen_features. - - set of features we saw in property_sets - """ - if not property_sets: - return ([], set()) - - properties = property_sets[0].all() - - these_features = set() - for p in property_sets[0].non_free(): - these_features.add(p.feature()) - - # Note: the algorithm as implemented here, as in original Jam code, appears to - # detect conflicts based on features, not properties. For example, if command - # line build request say: - # - # <a>1/<b>1 c<1>/<b>1 - # - # It will decide that those two property sets conflict, because they both specify - # a value for 'b' and will not try building "<a>1 <c1> <b1>", but rather two - # different property sets. This is a topic for future fixing, maybe. - if these_features & seen_features: - - (inner_result, inner_seen) = __x_product_aux(property_sets[1:], seen_features) - return (inner_result, inner_seen | these_features) - - else: - - result = [] - (inner_result, inner_seen) = __x_product_aux(property_sets[1:], seen_features | these_features) - if inner_result: - for inner in inner_result: - result.append(properties + inner) - else: - result.append(properties) - - if inner_seen & these_features: - # Some of elements in property_sets[1:] conflict with elements of property_sets[0], - # Try again, this time omitting elements of property_sets[0] - (inner_result2, inner_seen2) = __x_product_aux(property_sets[1:], seen_features) - result.extend(inner_result2) - - return (result, inner_seen | these_features) - - - -def looks_like_implicit_value(v): - """Returns true if 'v' is either implicit value, or - the part before the first '-' symbol is implicit value.""" - if feature.is_implicit_value(v): - return 1 - else: - split = v.split("-") - if feature.is_implicit_value(split[0]): - return 1 - - return 0 - -def from_command_line(command_line): - """Takes the command line tokens (such as taken from ARGV rule) - and constructs build request from it. Returns a list of two - lists. First is the set of targets specified in the command line, - and second is the set of requested build properties.""" - - targets = [] - properties = [] - - for e in command_line: - if e[0] != "-": - # Build request spec either has "=" in it, or completely - # consists of implicit feature values. - if e.find("=") != -1 or looks_like_implicit_value(e.split("/")[0]): - properties += convert_command_line_element(e) - else: - targets.append(e) - - return [targets, properties] - -# Converts one element of command line build request specification into -# internal form. -def convert_command_line_element(e): - - result = None - parts = e.split("/") - for p in parts: - m = p.split("=") - if len(m) > 1: - feature = m[0] - values = m[1].split(",") - lresult = [("<%s>%s" % (feature, v)) for v in values] - else: - lresult = p.split(",") - - if p.find('-') == -1: - # FIXME: first port property.validate - # property.validate cannot handle subfeatures, - # so we avoid the check here. - #for p in lresult: - # property.validate(p) - pass - - if not result: - result = lresult - else: - result = [e1 + "/" + e2 for e1 in result for e2 in lresult] - - return [property_set.create(b2.build.feature.split(r)) for r in result] - -### -### rule __test__ ( ) -### { -### import assert feature ; -### -### feature.prepare-test build-request-test-temp ; -### -### import build-request ; -### import build-request : expand_no_defaults : build-request.expand_no_defaults ; -### import errors : try catch ; -### import feature : feature subfeature ; -### -### feature toolset : gcc msvc borland : implicit ; -### subfeature toolset gcc : version : 2.95.2 2.95.3 2.95.4 -### 3.0 3.0.1 3.0.2 : optional ; -### -### feature variant : debug release : implicit composite ; -### feature inlining : on off ; -### feature "include" : : free ; -### -### feature stdlib : native stlport : implicit ; -### -### feature runtime-link : dynamic static : symmetric ; -### -### -### local r ; -### -### r = [ build-request.from-command-line bjam debug runtime-link=dynamic ] ; -### assert.equal [ $(r).get-at 1 ] : ; -### assert.equal [ $(r).get-at 2 ] : debug <runtime-link>dynamic ; -### -### try ; -### { -### -### build-request.from-command-line bjam gcc/debug runtime-link=dynamic/static ; -### } -### catch \"static\" is not a value of an implicit feature ; -### -### -### r = [ build-request.from-command-line bjam -d2 --debug debug target runtime-link=dynamic ] ; -### assert.equal [ $(r).get-at 1 ] : target ; -### assert.equal [ $(r).get-at 2 ] : debug <runtime-link>dynamic ; -### -### r = [ build-request.from-command-line bjam debug runtime-link=dynamic,static ] ; -### assert.equal [ $(r).get-at 1 ] : ; -### assert.equal [ $(r).get-at 2 ] : debug <runtime-link>dynamic <runtime-link>static ; -### -### r = [ build-request.from-command-line bjam debug gcc/runtime-link=dynamic,static ] ; -### assert.equal [ $(r).get-at 1 ] : ; -### assert.equal [ $(r).get-at 2 ] : debug gcc/<runtime-link>dynamic -### gcc/<runtime-link>static ; -### -### r = [ build-request.from-command-line bjam msvc gcc,borland/runtime-link=static ] ; -### assert.equal [ $(r).get-at 1 ] : ; -### assert.equal [ $(r).get-at 2 ] : msvc gcc/<runtime-link>static -### borland/<runtime-link>static ; -### -### r = [ build-request.from-command-line bjam gcc-3.0 ] ; -### assert.equal [ $(r).get-at 1 ] : ; -### assert.equal [ $(r).get-at 2 ] : gcc-3.0 ; -### -### feature.finish-test build-request-test-temp ; -### } -### -### diff --git a/jam-files/boost-build/build/configure.jam b/jam-files/boost-build/build/configure.jam deleted file mode 100644 index 14c1328a..00000000 --- a/jam-files/boost-build/build/configure.jam +++ /dev/null @@ -1,237 +0,0 @@ -# Copyright (c) 2010 Vladimir Prus. -# -# Use, modification and distribution is subject to the Boost Software -# License Version 1.0. (See accompanying file LICENSE_1_0.txt or -# http://www.boost.org/LICENSE_1_0.txt) - -# This module defines function to help with two main tasks: -# -# - Discovering build-time configuration for the purposes of adjusting -# build process. -# - Reporting what is built, and how it is configured. - -import targets ; -import errors ; -import targets ; -import sequence ; -import property ; -import property-set ; -import "class" : new ; -import common ; -import path ; - -rule log-summary ( ) -{ - -} - -.width = 30 ; - -rule set-width ( width ) -{ - .width = $(width) ; -} - -# Declare that the components specified by the parameter exist. -rule register-components ( components * ) -{ - .components += $(components) ; -} - -# Declare that the components specified by the parameters will -# be build. -rule components-building ( components * ) -{ - .built-components += $(components) ; -} - -# Report something about component configuration that the -# user should better know. -rule log-component-configuration ( component : message ) -{ - # FIXME: implement per-property-set logs - .component-logs.$(component) += $(message) ; -} - - - -rule log-check-result ( result ) -{ - if ! $(.announced-checks) - { - ECHO "Performing configuration checks\n" ; - .announced-checks = 1 ; - } - - ECHO $(result) ; - #.check-results += $(result) ; -} - -rule log-library-search-result ( library : result ) -{ - local x = [ PAD " - $(library) : $(result)" : $(.width) ] ; - log-check-result "$(x)" ; -} - -rule print-component-configuration ( ) -{ - local c = [ sequence.unique $(.components) ] ; - - ECHO "\nComponent configuration:\n" ; - for c in $(.components) - { - local s ; - if $(c) in $(.built-components) - { - s = "building" ; - } - else - { - s = "not building" ; - } - ECHO [ PAD " - $(c)" : $(.width) ] ": $(s)" ; - for local m in $(.component-logs.$(c)) - { - ECHO " -" $(m) ; - } - } - ECHO ; -} - -rule print-configure-checks-summary ( ) -{ - # FIXME: the problem with that approach is tha - # the user sees checks summary when all checks are - # done, and has no progress reporting while the - # checks are being executed. - if $(.check-results) - { - ECHO "Configuration checks summary\n" ; - - for local r in $(.check-results) - { - ECHO $(r) ; - } - ECHO ; - } -} - -# Attempt to build a metatarget named by 'metatarget-reference' -# in context of 'project' with properties 'ps'. -# Returns non-empty value if build is OK. -rule builds-raw ( metatarget-reference : project : ps : what : retry ? ) -{ - local result ; - - if ! $(retry) && ! $(.$(what)-tested.$(ps)) - { - .$(what)-tested.$(ps) = true ; - - local targets = [ targets.generate-from-reference - $(metatarget-reference) : $(project) : $(ps) ] ; - - local jam-targets ; - for local t in $(targets[2-]) - { - jam-targets += [ $(t).actualize ] ; - } - - if ! UPDATE_NOW in [ RULENAMES ] - { - # Cannot determine. Assume existance. - } - else - { - local x = [ PAD " - $(what)" : $(.width) ] ; - if [ UPDATE_NOW $(jam-targets) : - $(.log-fd) : ignore-minus-n : ignore-minus-q ] - { - .$(what)-supported.$(ps) = yes ; - result = true ; - log-check-result "$(x) : yes" ; - } - else - { - log-check-result "$(x) : no" ; - } - } - return $(result) ; - } - else - { - return $(.$(what)-supported.$(ps)) ; - } -} - -rule builds ( metatarget-reference : properties * : what ? : retry ? ) -{ - what ?= "$(metatarget-reference) builds" ; - - # FIXME: this should not be hardcoded. Other checks might - # want to consider different set of features as relevant. - local toolset = [ property.select <toolset> : $(properties) ] ; - local toolset-version-property = "<toolset-$(toolset:G=):version>" ; - local relevant = [ property.select <target-os> <toolset> $(toolset-version-property) - <address-model> <architecture> - : $(properties) ] ; - local ps = [ property-set.create $(relevant) ] ; - local t = [ targets.current ] ; - local p = [ $(t).project ] ; - - return [ builds-raw $(metatarget-reference) : $(p) : $(ps) : $(what) : $(retry) ] ; -} - - -# Called by Boost.Build startup code to specify name of a file -# that will receive results of configure checks. This -# should never be called by users. -rule set-log-file ( log-file ) -{ - path.makedirs [ path.parent $(log-file) ] ; - - .log-fd = [ FILE_OPEN $(log-file) : "w" ] ; -} - -# Frontend rules - -class check-target-builds-worker -{ - import configure ; - import property-set ; - import targets ; - import property ; - - rule __init__ ( target message ? : true-properties * : false-properties * ) - { - self.target = $(target) ; - self.message = $(message) ; - self.true-properties = $(true-properties) ; - self.false-properties = $(false-properties) ; - } - - rule check ( properties * ) - { - local choosen ; - if [ configure.builds $(self.target) : $(properties) : $(self.message) ] - { - choosen = $(self.true-properties) ; - } - else - { - choosen = $(self.false-properties) ; - } - return [ property.evaluate-conditionals-in-context $(choosen) : $(properties) ] ; - } -} - - -rule check-target-builds ( target message ? : true-properties * : false-properties * ) -{ - local instance = [ new check-target-builds-worker $(target) $(message) : $(true-properties) - : $(false-properties) ] ; - return <conditional>@$(instance).check ; -} - -IMPORT $(__name__) : check-target-builds : : check-target-builds ; - - diff --git a/jam-files/boost-build/build/configure.py b/jam-files/boost-build/build/configure.py deleted file mode 100644 index 0426832c..00000000 --- a/jam-files/boost-build/build/configure.py +++ /dev/null @@ -1,164 +0,0 @@ -# Status: ported. -# Base revison: 64488 -# -# Copyright (c) 2010 Vladimir Prus. -# -# Use, modification and distribution is subject to the Boost Software -# License Version 1.0. (See accompanying file LICENSE_1_0.txt or -# http://www.boost.org/LICENSE_1_0.txt) - -# This module defines function to help with two main tasks: -# -# - Discovering build-time configuration for the purposes of adjusting -# build process. -# - Reporting what is built, and how it is configured. - -import b2.build.property as property -import b2.build.property_set as property_set - -import b2.build.targets - -from b2.manager import get_manager -from b2.util.sequence import unique -from b2.util import bjam_signature, value_to_jam - -import bjam -import os - -__width = 30 - -def set_width(width): - global __width - __width = 30 - -__components = [] -__built_components = [] -__component_logs = {} -__announced_checks = False - -__log_file = None -__log_fd = -1 - -def register_components(components): - """Declare that the components specified by the parameter exist.""" - __components.extend(components) - -def components_building(components): - """Declare that the components specified by the parameters will be build.""" - __built_components.extend(components) - -def log_component_configuration(component, message): - """Report something about component configuration that the user should better know.""" - __component_logs.setdefault(component, []).append(message) - -def log_check_result(result): - global __announced_checks - if not __announced_checks: - print "Performing configuration checks" - __announced_checks = True - - print result - -def log_library_search_result(library, result): - log_check_result((" - %(library)s : %(result)s" % locals()).rjust(width)) - - -def print_component_configuration(): - - print "\nComponent configuration:" - for c in __components: - if c in __built_components: - s = "building" - else: - s = "not building" - message = " - %s)" % c - message = message.rjust(__width) - message += " : " + s - for m in __component_logs.get(c, []): - print " -" + m - print "" - -__builds_cache = {} - -def builds(metatarget_reference, project, ps, what): - # Attempt to build a metatarget named by 'metatarget-reference' - # in context of 'project' with properties 'ps'. - # Returns non-empty value if build is OK. - - result = [] - - existing = __builds_cache.get((what, ps), None) - if existing is None: - - result = False - __builds_cache[(what, ps)] = False - - targets = b2.build.targets.generate_from_reference( - metatarget_reference, project, ps).targets() - jam_targets = [] - for t in targets: - jam_targets.append(t.actualize()) - - x = (" - %s" % what).rjust(__width) - if bjam.call("UPDATE_NOW", jam_targets, str(__log_fd), "ignore-minus-n"): - __builds_cache[(what, ps)] = True - result = True - log_check_result("%s: yes" % x) - else: - log_check_result("%s: no" % x) - - return result - else: - return existing - -def set_log_file(log_file_name): - # Called by Boost.Build startup code to specify name of a file - # that will receive results of configure checks. This - # should never be called by users. - global __log_file, __log_fd - dirname = os.path.dirname(log_file_name) - if not os.path.exists(dirname): - os.makedirs(dirname) - # Make sure to keep the file around, so that it's not - # garbage-collected and closed - __log_file = open(log_file_name, "w") - __log_fd = __log_file.fileno() - -# Frontend rules - -class CheckTargetBuildsWorker: - - def __init__(self, target, true_properties, false_properties): - self.target = target - self.true_properties = property.create_from_strings(true_properties, True) - self.false_properties = property.create_from_strings(false_properties, True) - - def check(self, ps): - - # FIXME: this should not be hardcoded. Other checks might - # want to consider different set of features as relevant. - toolset = ps.get('toolset')[0] - toolset_version_property = "<toolset-" + toolset + ":version>" ; - relevant = ps.get_properties('target-os') + \ - ps.get_properties("toolset") + \ - ps.get_properties(toolset_version_property) + \ - ps.get_properties("address-model") + \ - ps.get_properties("architecture") - rps = property_set.create(relevant) - t = get_manager().targets().current() - p = t.project() - if builds(self.target, p, rps, "%s builds" % self.target): - choosen = self.true_properties - else: - choosen = self.false_properties - return property.evaluate_conditionals_in_context(choosen, ps) - -@bjam_signature((["target"], ["true_properties", "*"], ["false_properties", "*"])) -def check_target_builds(target, true_properties, false_properties): - worker = CheckTargetBuildsWorker(target, true_properties, false_properties) - value = value_to_jam(worker.check) - return "<conditional>" + value - -get_manager().projects().add_rule("check-target-builds", check_target_builds) - - diff --git a/jam-files/boost-build/build/engine.py b/jam-files/boost-build/build/engine.py deleted file mode 100644 index be9736e0..00000000 --- a/jam-files/boost-build/build/engine.py +++ /dev/null @@ -1,172 +0,0 @@ -# Copyright Pedro Ferreira 2005. -# Copyright Vladimir Prus 2007. -# Distributed under the Boost -# Software License, Version 1.0. (See accompanying -# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - -bjam_interface = __import__('bjam') - -import operator -import re - -import b2.build.property_set as property_set -import b2.util - -class BjamAction: - """Class representing bjam action defined from Python.""" - - def __init__(self, action_name, function): - self.action_name = action_name - self.function = function - - def __call__(self, targets, sources, property_set): - if self.function: - self.function(targets, sources, property_set) - - # Bjam actions defined from Python have only the command - # to execute, and no associated jam procedural code. So - # passing 'property_set' to it is not necessary. - bjam_interface.call("set-update-action", self.action_name, - targets, sources, []) - -class BjamNativeAction: - """Class representing bjam action defined by Jam code. - - We still allow to associate a Python callable that will - be called when this action is installed on any target. - """ - - def __init__(self, action_name, function): - self.action_name = action_name - self.function = function - - def __call__(self, targets, sources, property_set): - if self.function: - self.function(targets, sources, property_set) - - p = [] - if property_set: - p = property_set.raw() - - b2.util.set_jam_action(self.action_name, targets, sources, p) - -action_modifiers = {"updated": 0x01, - "together": 0x02, - "ignore": 0x04, - "quietly": 0x08, - "piecemeal": 0x10, - "existing": 0x20} - -class Engine: - """ The abstract interface to a build engine. - - For now, the naming of targets, and special handling of some - target variables like SEARCH and LOCATE make this class coupled - to bjam engine. - """ - def __init__ (self): - self.actions = {} - - def add_dependency (self, targets, sources): - """Adds a dependency from 'targets' to 'sources' - - Both 'targets' and 'sources' can be either list - of target names, or a single target name. - """ - if isinstance (targets, str): - targets = [targets] - if isinstance (sources, str): - sources = [sources] - - for target in targets: - for source in sources: - self.do_add_dependency (target, source) - - def set_target_variable (self, targets, variable, value, append=0): - """ Sets a target variable. - - The 'variable' will be available to bjam when it decides - where to generate targets, and will also be available to - updating rule for that 'taret'. - """ - if isinstance (targets, str): - targets = [targets] - - for target in targets: - self.do_set_target_variable (target, variable, value, append) - - def set_update_action (self, action_name, targets, sources, properties=property_set.empty()): - """ Binds a target to the corresponding update action. - If target needs to be updated, the action registered - with action_name will be used. - The 'action_name' must be previously registered by - either 'register_action' or 'register_bjam_action' - method. - """ - assert(isinstance(properties, property_set.PropertySet)) - if isinstance (targets, str): - targets = [targets] - self.do_set_update_action (action_name, targets, sources, properties) - - def register_action (self, action_name, command, bound_list = [], flags = [], - function = None): - """Creates a new build engine action. - - Creates on bjam side an action named 'action_name', with - 'command' as the command to be executed, 'bound_variables' - naming the list of variables bound when the command is executed - and specified flag. - If 'function' is not None, it should be a callable taking three - parameters: - - targets - - sources - - instance of the property_set class - This function will be called by set_update_action, and can - set additional target variables. - """ - if self.actions.has_key(action_name): - raise "Bjam action %s is already defined" % action_name - - assert(isinstance(flags, list)) - - bjam_flags = reduce(operator.or_, - (action_modifiers[flag] for flag in flags), 0) - - bjam_interface.define_action(action_name, command, bound_list, bjam_flags) - - self.actions[action_name] = BjamAction(action_name, function) - - def register_bjam_action (self, action_name, function=None): - """Informs self that 'action_name' is declared in bjam. - - From this point, 'action_name' is a valid argument to the - set_update_action method. The action_name should be callable - in the global module of bjam. - """ - - # We allow duplicate calls to this rule for the same - # action name. This way, jamfile rules that take action names - # can just register them without specially checking if - # action is already registered. - if not self.actions.has_key(action_name): - self.actions[action_name] = BjamNativeAction(action_name, function) - - # Overridables - - - def do_set_update_action (self, action_name, targets, sources, property_set): - action = self.actions.get(action_name) - if not action: - raise Exception("No action %s was registered" % action_name) - action(targets, sources, property_set) - - def do_set_target_variable (self, target, variable, value, append): - if append: - bjam_interface.call("set-target-variable", target, variable, value, "true") - else: - bjam_interface.call("set-target-variable", target, variable, value) - - def do_add_dependency (self, target, source): - bjam_interface.call("DEPENDS", target, source) - - diff --git a/jam-files/boost-build/build/errors.py b/jam-files/boost-build/build/errors.py deleted file mode 100644 index d9dceefe..00000000 --- a/jam-files/boost-build/build/errors.py +++ /dev/null @@ -1,127 +0,0 @@ -# Status: being written afresh by Vladimir Prus - -# Copyright 2007 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) - -# This file is supposed to implement error reporting for Boost.Build. -# Experience with jam version has shown that printing full backtrace -# on each error is buffling. Further, for errors printed after parsing -- -# during target building, the stacktrace does not even mention what -# target is being built. - -# This module implements explicit contexts -- where other code can -# communicate which projects/targets are being built, and error -# messages will show those contexts. For programming errors, -# Python assertions are to be used. - -import bjam -import traceback -import sys - -def format(message, prefix=""): - parts = str(message).split("\n") - return "\n".join(prefix+p for p in parts) - - -class Context: - - def __init__(self, message, nested=None): - self.message_ = message - self.nested_ = nested - - def report(self, indent=""): - print indent + " -", self.message_ - if self.nested_: - print indent + " declared at:" - for n in self.nested_: - n.report(indent + " ") - -class JamfileContext: - - def __init__(self): - raw = bjam.backtrace() - self.raw_ = raw - - def report(self, indent=""): - for r in self.raw_: - print indent + " - %s:%s" % (r[0], r[1]) - -class ExceptionWithUserContext(Exception): - - def __init__(self, message, context, - original_exception=None, original_tb=None, stack=None): - Exception.__init__(self, message) - self.context_ = context - self.original_exception_ = original_exception - self.original_tb_ = original_tb - self.stack_ = stack - - def report(self): - print "error:", self.args[0] - if self.original_exception_: - print format(str(self.original_exception_), " ") - print - print " error context (most recent first):" - for c in self.context_[::-1]: - c.report() - print - if "--stacktrace" in bjam.variable("ARGV"): - if self.original_tb_: - traceback.print_tb(self.original_tb_) - elif self.stack_: - for l in traceback.format_list(self.stack_): - print l, - else: - print " use the '--stacktrace' option to get Python stacktrace" - print - -def user_error_checkpoint(callable): - def wrapper(self, *args): - errors = self.manager().errors() - try: - return callable(self, *args) - except ExceptionWithUserContext, e: - raise - except Exception, e: - errors.handle_stray_exception(e) - finally: - errors.pop_user_context() - - return wrapper - -class Errors: - - def __init__(self): - self.contexts_ = [] - self._count = 0 - - def count(self): - return self._count - - def push_user_context(self, message, nested=None): - self.contexts_.append(Context(message, nested)) - - def pop_user_context(self): - del self.contexts_[-1] - - def push_jamfile_context(self): - self.contexts_.append(JamfileContext()) - - def pop_jamfile_context(self): - del self.contexts_[-1] - - def capture_user_context(self): - return self.contexts_[:] - - def handle_stray_exception(self, e): - raise ExceptionWithUserContext("unexpected exception", self.contexts_[:], - e, sys.exc_info()[2]) - def __call__(self, message): - self._count = self._count + 1 - raise ExceptionWithUserContext(message, self.contexts_[:], - stack=traceback.extract_stack()) - - - - diff --git a/jam-files/boost-build/build/feature.jam b/jam-files/boost-build/build/feature.jam deleted file mode 100644 index 6f54adef..00000000 --- a/jam-files/boost-build/build/feature.jam +++ /dev/null @@ -1,1335 +0,0 @@ -# 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 ; -} diff --git a/jam-files/boost-build/build/feature.py b/jam-files/boost-build/build/feature.py deleted file mode 100644 index 315a18e9..00000000 --- a/jam-files/boost-build/build/feature.py +++ /dev/null @@ -1,905 +0,0 @@ -# Status: ported, except for unit tests. -# Base revision: 64488 -# -# 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 re - -from b2.util import utility, bjam_signature -import b2.util.set -from b2.util.utility import add_grist, get_grist, ungrist, replace_grist, to_seq -from b2.exceptions import * - -__re_split_subfeatures = re.compile ('<(.*):(.*)>') -__re_no_hyphen = re.compile ('^([^:]+)$') -__re_slash_or_backslash = re.compile (r'[\\/]') - -class Feature(object): - - # Map from string attribute names to integers bit flags. - # This will be initialized after declaration of the class. - _attribute_name_to_integer = {} - - def __init__(self, name, values, attributes): - self._name = name - self._values = values - self._default = None - self._attributes = 0 - for a in attributes: - self._attributes = self._attributes | Feature._attribute_name_to_integer[a] - self._attributes_string_list = attributes - self._subfeatures = [] - self._parent = None - - def name(self): - return self._name - - def values(self): - return self._values - - def add_values(self, values): - self._values.extend(values) - - def attributes(self): - return self._attributes - - def set_default(self, value): - self._default = value - - def default(self): - return self._default - - # FIXME: remove when we fully move to using classes for features/properties - def attributes_string_list(self): - return self._attributes_string_list - - def subfeatures(self): - return self._subfeatures - - def add_subfeature(self, name): - self._subfeatures.append(name) - - def parent(self): - """For subfeatures, return pair of (parent_feature, value). - - Value may be None if this subfeature is not specific to any - value of the parent feature. - """ - return self._parent - - def set_parent(self, feature, value): - self._parent = (feature, value) - - def __str__(self): - return self._name - - -def reset (): - """ Clear the module state. This is mainly for testing purposes. - """ - global __all_attributes, __all_features, __implicit_features, __composite_properties - global __features_with_attributes, __subfeature_from_value, __all_top_features, __free_features - global __all_subfeatures - - # The list with all attribute names. - __all_attributes = [ 'implicit', - 'composite', - 'optional', - 'symmetric', - 'free', - 'incidental', - 'path', - 'dependency', - 'propagated', - 'link-incompatible', - 'subfeature', - 'order-sensitive' - ] - i = 1 - for a in __all_attributes: - setattr(Feature, a.upper(), i) - Feature._attribute_name_to_integer[a] = i - def probe(self, flag=i): - return getattr(self, "_attributes") & flag - setattr(Feature, a.replace("-", "_"), probe) - i = i << 1 - - # A map containing all features. The key is the feature name. - # The value is an instance of Feature class. - __all_features = {} - - # All non-subfeatures. - __all_top_features = [] - - # Maps valus to the corresponding implicit feature - __implicit_features = {} - - # A map containing all composite properties. The key is a Property instance, - # and the value is a list of Property instances - __composite_properties = {} - - __features_with_attributes = {} - for attribute in __all_attributes: - __features_with_attributes [attribute] = [] - - # Maps a value to the corresponding subfeature name. - __subfeature_from_value = {} - - # All free features - __free_features = [] - - __all_subfeatures = [] - -reset () - -def enumerate (): - """ Returns an iterator to the features map. - """ - return __all_features.iteritems () - -def get(name): - """Return the Feature instance for the specified name. - - Throws if no feature by such name exists - """ - return __all_features[name] - -# FIXME: prepare-test/finish-test? - -@bjam_signature((["name"], ["values", "*"], ["attributes", "*"])) -def feature (name, values, attributes = []): - """ Declares a new feature with the given name, values, and attributes. - name: the feature name - values: a sequence of the allowable values - may be extended later with feature.extend - attributes: a sequence of the feature's attributes (e.g. implicit, free, propagated, ...) - """ - __validate_feature_attributes (name, attributes) - - feature = Feature(name, [], attributes) - __all_features[name] = feature - # Temporary measure while we have not fully moved from 'gristed strings' - __all_features["<" + name + ">"] = feature - - for attribute in attributes: - __features_with_attributes [attribute].append (name) - - name = add_grist(name) - - if 'subfeature' in attributes: - __all_subfeatures.append(name) - else: - __all_top_features.append(feature) - - extend (name, values) - - # FIXME: why his is needed. - if 'free' in attributes: - __free_features.append (name) - - return feature - -@bjam_signature((["feature"], ["value"])) -def set_default (feature, value): - """ Sets the default value of the given feature, overriding any previous default. - feature: the name of the feature - value: the default value to assign - """ - f = __all_features[feature] - attributes = f.attributes() - bad_attribute = None - - if attributes & Feature.FREE: - bad_attribute = "free" - elif attributes & Feature.OPTIONAL: - bad_attribute = "optional" - - if bad_attribute: - raise InvalidValue ("%s property %s cannot have a default" % (bad_attribute, feature.name())) - - if not value in f.values(): - raise InvalidValue ("The specified default value, '%s' is invalid.\n" % value + "allowed values are: %s" % values) - - f.set_default(value) - -def defaults(features): - """ Returns the default property values for the given features. - """ - # FIXME: should merge feature and property modules. - import property - - result = [] - for f in features: - if not f.free() and not f.optional() and f.default(): - result.append(property.Property(f, f.default())) - - return result - -def valid (names): - """ Returns true iff all elements of names are valid features. - """ - def valid_one (name): return __all_features.has_key (name) - - if isinstance (names, str): - return valid_one (names) - else: - return [ valid_one (name) for name in names ] - -def attributes (feature): - """ Returns the attributes of the given feature. - """ - return __all_features[feature].attributes_string_list() - -def values (feature): - """ Return the values of the given feature. - """ - validate_feature (feature) - return __all_features[feature].values() - -def is_implicit_value (value_string): - """ Returns true iff 'value_string' is a value_string - of an implicit feature. - """ - - if __implicit_features.has_key(value_string): - return __implicit_features[value_string] - - v = value_string.split('-') - - if not __implicit_features.has_key(v[0]): - return False - - feature = __implicit_features[v[0]] - - for subvalue in (v[1:]): - if not __find_implied_subfeature(feature, subvalue, v[0]): - return False - - return True - -def implied_feature (implicit_value): - """ Returns the implicit feature associated with the given implicit value. - """ - components = implicit_value.split('-') - - if not __implicit_features.has_key(components[0]): - raise InvalidValue ("'%s' is not a value of an implicit feature" % implicit_value) - - return __implicit_features[components[0]] - -def __find_implied_subfeature (feature, subvalue, value_string): - - #if value_string == None: value_string = '' - - if not __subfeature_from_value.has_key(feature) \ - or not __subfeature_from_value[feature].has_key(value_string) \ - or not __subfeature_from_value[feature][value_string].has_key (subvalue): - return None - - return __subfeature_from_value[feature][value_string][subvalue] - -# 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 -# feature # The main feature name -# subvalue # The value of one of its subfeatures -# value-string # The value of the main feature - -def implied_subfeature (feature, subvalue, value_string): - result = __find_implied_subfeature (feature, subvalue, value_string) - if not result: - raise InvalidValue ("'%s' is not a known subfeature value of '%s%s'" % (subvalue, feature, value_string)) - - return result - -def validate_feature (name): - """ Checks if all name is a valid feature. Otherwise, raises an exception. - """ - if not __all_features.has_key(name): - raise InvalidFeature ("'%s' is not a valid feature name" % name) - else: - return __all_features[name] - -def valid (names): - """ Returns true iff all elements of names are valid features. - """ - def valid_one (name): return __all_features.has_key (name) - - if isinstance (names, str): - return valid_one (names) - else: - return [ valid_one (name) for name in names ] - -# Uses Property -def __expand_subfeatures_aux (property, 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. - """ - f = property.feature() - v = property.value() - if not dont_validate: - validate_value_string(f, v) - - components = v.split ("-") - - v = components[0] - - import property - - result = [property.Property(f, components[0])] - - subvalues = components[1:] - - while len(subvalues) > 0: - subvalue = subvalues [0] # pop the head off of subvalues - subvalues = subvalues [1:] - - subfeature = __find_implied_subfeature (f, subvalue, v) - - # If no subfeature was found, reconstitute the value string and use that - if not subfeature: - return [property.Property(f, '-'.join(components))] - - result.append(property.Property(subfeature, subvalue)) - - return result - -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: - # Don't expand subfeatures in subfeatures - if p.feature().subfeature(): - result.append (p) - else: - result.extend(__expand_subfeatures_aux (p, dont_validate)) - - return result - - - -# rule extend was defined as below: - # 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 * ) -# -# Now, the specific rule must be called, depending on the desired operation: -# extend_feature -# extend_subfeature - -def extend (name, values): - """ Adds the given values to the given feature. - """ - name = add_grist (name) - __validate_feature (name) - feature = __all_features [name] - - if feature.implicit(): - for v in values: - if __implicit_features.has_key(v): - raise BaseException ("'%s' is already associated with the feature '%s'" % (v, __implicit_features [v])) - - __implicit_features[v] = feature - - if len (feature.values()) == 0 and len (values) > 0: - # This is the first value specified for this feature, - # take it as default value - feature.set_default(values[0]) - - feature.add_values(values) - -def validate_value_string (f, value_string): - """ Checks that value-string is a valid value-string for the given feature. - """ - if f.free() or value_string in f.values(): - return - - values = [value_string] - - if f.subfeatures(): - if not value_string in f.values() and \ - not value_string in f.subfeatures(): - values = value_string.split('-') - - # An empty value is allowed for optional features - if not values[0] in f.values() and \ - (values[0] or not f.optional()): - raise InvalidValue ("'%s' is not a known value of feature '%s'\nlegal values: '%s'" % (values [0], feature, f.values())) - - for v in values [1:]: - # this will validate any subfeature values in value-string - implied_subfeature(f, v, values[0]) - - -""" 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 specifc to <toolset>gcc-2.95.2 as follows: - - extend-subfeature toolset gcc-2.95.2 : target-platform : mingw ; - - 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: The name of the subfeature. - - subvalues: The additional values of the subfeature being defined. -""" -def extend_subfeature (feature_name, value_string, subfeature_name, subvalues): - - feature = validate_feature(feature_name) - - if value_string: - validate_value_string(feature, value_string) - - subfeature_name = feature_name + '-' + __get_subfeature_name (subfeature_name, value_string) - - extend(subfeature_name, subvalues) ; - subfeature = __all_features[subfeature_name] - - if value_string == None: value_string = '' - - if not __subfeature_from_value.has_key(feature): - __subfeature_from_value [feature] = {} - - if not __subfeature_from_value[feature].has_key(value_string): - __subfeature_from_value [feature][value_string] = {} - - for subvalue in subvalues: - __subfeature_from_value [feature][value_string][subvalue] = subfeature - -@bjam_signature((["feature_name", "value_string", "?"], ["subfeature"], - ["subvalues", "*"], ["attributes", "*"])) -def subfeature (feature_name, value_string, subfeature, subvalues, attributes = []): - """ Declares a subfeature. - feature_name: Root feature that is not a subfeature. - value_string: An optional 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. - """ - parent_feature = validate_feature (feature_name) - - # Add grist to the subfeature name if a value-string was supplied - subfeature_name = __get_subfeature_name (subfeature, value_string) - - if subfeature_name in __all_features[feature_name].subfeatures(): - message = "'%s' already declared as a subfeature of '%s'" % (subfeature, feature_name) - message += " specific to '%s'" % value_string - raise BaseException (message) - - # First declare the subfeature as a feature in its own right - f = feature (feature_name + '-' + subfeature_name, subvalues, attributes + ['subfeature']) - f.set_parent(parent_feature, value_string) - - parent_feature.add_subfeature(f) - - # Now make sure the subfeature values are known. - extend_subfeature (feature_name, value_string, subfeature, subvalues) - - -@bjam_signature((["composite_property_s"], ["component_properties_s", "*"])) -def compose (composite_property_s, component_properties_s): - """ Sets the components of the given composite property. - - All paremeters are <feature>value strings - """ - import property - - component_properties_s = to_seq (component_properties_s) - composite_property = property.create_from_string(composite_property_s) - f = composite_property.feature() - - if len(component_properties_s) > 0 and isinstance(component_properties_s[0], property.Property): - component_properties = component_properties_s - else: - component_properties = [property.create_from_string(p) for p in component_properties_s] - - if not f.composite(): - raise BaseException ("'%s' is not a composite feature" % f) - - if __composite_properties.has_key(property): - raise BaseException ('components of "%s" already set: %s' % (composite_property, str (__composite_properties[composite_property]))) - - if composite_property in component_properties: - raise BaseException ('composite property "%s" cannot have itself as a component' % composite_property) - - __composite_properties[composite_property] = component_properties - - -def expand_composite(property): - result = [ property ] - if __composite_properties.has_key(property): - for p in __composite_properties[property]: - result.extend(expand_composite(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 free_features (): - """ Returns all free features. - """ - return __free_features - -def expand_composites (properties): - """ Expand all composite properties in the set so that all components - are explicitly expressed. - """ - explicit_features = set(p.feature() for p in properties) - - result = [] - - # now expand composite features - for p in properties: - expanded = expand_composite(p) - - for x in expanded: - if not x in result: - f = x.feature() - - if f.free(): - result.append (x) - elif not x in properties: # x is the result of expansion - if not f in explicit_features: # not explicitly-specified - if any(r.feature() == f for r in result): - raise FeatureConflict( - "expansions of composite features result in " - "conflicting values for '%s'\nvalues: '%s'\none contributing composite property was '%s'" % - (f.name(), [r.value() for r in result if r.feature() == f] + [x.value()], p)) - else: - result.append (x) - elif any(r.feature() == f for r in result): - raise FeatureConflict ("explicitly-specified values of non-free feature '%s' conflict\n" - "existing values: '%s'\nvalue from expanding '%s': '%s'" % (f, - [r.value() for r in result if r.feature() == f], p, x.value())) - else: - result.append (x) - - return result - -# Uses Property -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 f.subfeature(): - return False - - p = f.parent() - if not p: - return False - - parent_feature = p[0] - parent_value = p[1] - - if parent_feature != parent_property.feature(): - return False - - if parent_value and parent_value != parent_property.value(): - return False - - return True - -def __is_subproperty_of (parent_property, p): - """ As is_subfeature_of, for subproperties. - """ - return is_subfeature_of (parent_property, p.feature()) - - -# Returns true iff the subvalue is 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. -def is_subvalue(feature, value_string, subfeature, subvalue): - - if not value_string: - value_string = '' - - if not __subfeature_from_value.has_key(feature): - return False - - if not __subfeature_from_value[feature].has_key(value_string): - return False - - if not __subfeature_from_value[feature][value_string].has_key(subvalue): - return False - - if __subfeature_from_value[feature][value_string][subvalue]\ - != subfeature: - return False - - return True - -def implied_subfeature (feature, subvalue, value_string): - result = __find_implied_subfeature (feature, subvalue, value_string) - if not result: - raise InvalidValue ("'%s' is not a known subfeature value of '%s%s'" % (subvalue, feature, value_string)) - - return result - - -# Uses Property -def expand (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. - """ - expanded = expand_subfeatures(properties) - return expand_composites (expanded) - -# Accepts list of Property objects -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] - - handled_features = set() - for p in properties: - # We don't add default for conditional properties. We don't want - # <variant>debug:<define>DEBUG to be takes as specified value for <variant> - if not p.condition(): - handled_features.add(p.feature()) - - missing_top = [f for f in __all_top_features if not f in handled_features] - more = defaults(missing_top) - result.extend(more) - for p in more: - handled_features.add(p.feature()) - - # Add defaults for subfeatures of features which are present - for p in result[:]: - s = p.feature().subfeatures() - more = defaults([s for s in p.feature().subfeatures() if not s in handled_features]) - for p in more: - handled_features.add(p.feature()) - result.extend(more) - - 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. - """ - - # remove properties implied by composite features - components = [] - for property in properties: - if __composite_properties.has_key (property): - components.extend(__composite_properties[property]) - properties = b2.util.set.difference (properties, components) - - # handle subfeatures and implicit features - - # move subfeatures to the end of the list - properties = [p for p in properties if not p.feature().subfeature()] +\ - [p for p in properties if p.feature().subfeature()] - - result = [] - while properties: - p = properties[0] - f = p.feature() - - # locate all subproperties of $(x[1]) in the property set - subproperties = __select_subproperties (p, properties) - - if subproperties: - # reconstitute the joined property name - subproperties.sort () - joined = b2.build.property.Property(p.feature(), p.value() + '-' + '-'.join ([sp.value() for sp in subproperties])) - result.append(joined) - - properties = b2.util.set.difference(properties[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 p.value() != f.default() or f.symmetric(): - result.append (p) - #\ - #or get_grist (fullp) in get_grist (components): - # FIXME: restore above - - - properties = properties[1:] - - return result - - -def split (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 is resilient to the - substitution of backslashes for slashes, since Jam, unbidden, - sometimes swaps slash direction on NT. - """ - - def split_one (properties): - pieces = re.split (__re_slash_or_backslash, properties) - result = [] - - for x in pieces: - if not get_grist (x) and len (result) > 0 and get_grist (result [-1]): - result = result [0:-1] + [ result [-1] + '/' + x ] - else: - result.append (x) - - return result - - if isinstance (properties, str): - return split_one (properties) - - result = [] - for p in properties: - result += split_one (p) - return result - - -def compress_subproperties (properties): - """ Combine all subproperties into their parent properties - - Requires: for every subproperty, there is a parent property. All - features are explicitly expressed. - - This rule probably shouldn't be needed, but - build-request.expand-no-defaults is being abused for unintended - purposes and it needs help - """ - result = [] - matched_subs = set() - all_subs = set() - for p in properties: - f = p.feature() - - if not f.subfeature(): - subs = __select_subproperties (p, properties) - if subs: - - matched_subs.update(subs) - - subvalues = '-'.join (sub.value() for sub in subs) - result.append(b2.build.property.Property( - p.feature(), p.value() + '-' + subvalues, - p.condition())) - else: - result.append(p) - - else: - all_subs.add(p) - - # TODO: this variables are used just for debugging. What's the overhead? - assert all_subs == matched_subs - - return result - -###################################################################################### -# Private methods - -def __select_subproperties (parent_property, properties): - return [ x for x in properties if __is_subproperty_of (parent_property, x) ] - -def __get_subfeature_name (subfeature, value_string): - if value_string == None: - prefix = '' - else: - prefix = value_string + ':' - - return prefix + subfeature - - -def __validate_feature_attributes (name, attributes): - for attribute in attributes: - if not attribute in __all_attributes: - raise InvalidAttribute ("unknown attributes: '%s' in feature declaration: '%s'" % (str (b2.util.set.difference (attributes, __all_attributes)), name)) - - if name in __all_features: - raise AlreadyDefined ("feature '%s' already defined" % name) - elif 'implicit' in attributes and 'free' in attributes: - raise InvalidAttribute ("free features cannot also be implicit (in declaration of feature '%s')" % name) - elif 'free' in attributes and 'propagated' in attributes: - raise InvalidAttribute ("free features cannot also be propagated (in declaration of feature '%s')" % name) - - -def __validate_feature (feature): - """ Generates an error if the feature is unknown. - """ - if not __all_features.has_key (feature): - raise BaseException ('unknown feature "%s"' % feature) - - -def __select_subfeatures (parent_property, features): - """ 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. - """ - return [f for f in features if is_subfeature_of (parent_property, f)] - -# FIXME: copy over tests. diff --git a/jam-files/boost-build/build/generators.jam b/jam-files/boost-build/build/generators.jam deleted file mode 100644 index 1515525f..00000000 --- a/jam-files/boost-build/build/generators.jam +++ /dev/null @@ -1,1408 +0,0 @@ -# Copyright Vladimir Prus 2002. -# Copyright Rene Rivera 2006. -# -# Distributed under the Boost Software License, Version 1.0. -# (See accompanying file LICENSE_1_0.txt or copy at -# http://www.boost.org/LICENSE_1_0.txt) - -# Manages 'generators' --- objects which can do transformation between different -# target types and contain algorithm for finding transformation from sources to -# targets. -# -# The main entry point to this module is generators.construct rule. It is given -# a list of source targets, desired target type and a set of properties. It -# starts by selecting 'viable generators', which have any chances of producing -# the desired target type with the required properties. Generators are ranked -# and a set of the most specific ones is selected. -# -# The most specific generators have their 'run' methods called, with the -# properties and list of sources. Each one selects a target which can be -# directly consumed, and tries to convert the remaining ones to the types it can -# consume. This is done by recursively calling 'construct' with all consumable -# types. -# -# If the generator has collected all the targets it needs, it creates targets -# corresponding to result, and returns it. When all generators have been run, -# results of one of them are selected and returned as a result. -# -# It is quite possible for 'construct' to return more targets that it was asked -# for. For example, if it were asked to generate a target of type EXE, but the -# only found generator produces both EXE and TDS (file with debug) information. -# The extra target will be returned. -# -# Likewise, when generator tries to convert sources to consumable types, it can -# get more targets that it was asked for. The question is what to do with extra -# targets. Boost.Build attempts to convert them to requested types, and attempts -# that as early as possible. Specifically, this is done after invoking each -# generator. TODO: An example is needed to document the rationale for trying -# extra target conversion at that point. -# -# In order for the system to be able to use a specific generator instance 'when -# needed', the instance needs to be registered with the system using -# generators.register() or one of its related rules. Unregistered generators may -# only be run explicitly and will not be considered by Boost.Build when when -# converting between given target types. - -import "class" : new ; -import errors ; -import property-set ; -import sequence ; -import set ; -import type ; -import utility ; -import virtual-target ; - - -if "--debug-generators" in [ modules.peek : ARGV ] -{ - .debug = true ; -} - - -# Updated cached viable source target type information as needed after a new -# target type gets defined. This is needed because if a target type is a viable -# source target type for some generator then all of the target type's derived -# target types should automatically be considered as viable source target types -# for the same generator as well. Does nothing if a non-derived target type is -# passed to it. -# -rule update-cached-information-with-a-new-type ( type ) -{ - local base-type = [ type.base $(type) ] ; - if $(base-type) - { - for local g in $(.vstg-cached-generators) - { - if $(base-type) in $(.vstg.$(g)) - { - .vstg.$(g) += $(type) ; - } - } - - for local t in $(.vst-cached-types) - { - if $(base-type) in $(.vst.$(t)) - { - .vst.$(t) += $(type) ; - } - } - } -} - - -# Clears cached viable source target type information except for target types -# and generators with all source types listed as viable. Should be called when -# something invalidates those cached values by possibly causing some new source -# types to become viable. -# -local rule invalidate-extendable-viable-source-target-type-cache ( ) -{ - local generators-with-cached-source-types = $(.vstg-cached-generators) ; - .vstg-cached-generators = ; - for local g in $(generators-with-cached-source-types) - { - if $(.vstg.$(g)) = * - { - .vstg-cached-generators += $(g) ; - } - else - { - .vstg.$(g) = ; - } - } - - local types-with-cached-source-types = $(.vst-cached-types) ; - .vst-cached-types = ; - for local t in $(types-with-cached-source-types) - { - if $(.vst.$(t)) = * - { - .vst-cached-types += $(t) ; - } - else - { - .vst.$(t) = ; - } - } -} - - -# Outputs a debug message if generators debugging is on. Each element of -# 'message' is checked to see if it is a class instance. If so, instead of the -# value, the result of 'str' call is output. -# -local rule generators.dout ( message * ) -{ - if $(.debug) - { - ECHO [ sequence.transform utility.str : $(message) ] ; - } -} - - -local rule indent ( ) -{ - return $(.indent:J="") ; -} - - -local rule increase-indent ( ) -{ - .indent += " " ; -} - - -local rule decrease-indent ( ) -{ - .indent = $(.indent[2-]) ; -} - - -# Models a generator. -# -class generator -{ - import generators : indent increase-indent decrease-indent generators.dout ; - import set ; - import utility ; - import feature ; - import errors ; - import sequence ; - import type ; - import virtual-target ; - import "class" : new ; - import property ; - import path ; - - EXPORT class@generator : indent increase-indent decrease-indent - generators.dout ; - - rule __init__ ( - id # Identifies the generator - should be name - # of the rule which sets up the build - # actions. - - composing ? # Whether generator processes each source - # target in turn, converting it to required - # types. Ordinary generators pass all - # sources together to the recursive - # generators.construct-types call. - - : source-types * # Types that this generator can handle. If - # empty, the generator can consume anything. - - : target-types-and-names + # Types the generator will create and, - # optionally, names for created targets. - # Each element should have the form - # type["(" name-pattern ")"], for example, - # obj(%_x). Generated target name will be - # found by replacing % with the name of - # source, provided an explicit name was not - # specified. - - : requirements * - ) - { - self.id = $(id) ; - self.rule-name = $(id) ; - self.composing = $(composing) ; - self.source-types = $(source-types) ; - self.target-types-and-names = $(target-types-and-names) ; - self.requirements = $(requirements) ; - - for local e in $(target-types-and-names) - { - # Create three parallel lists: one with the list of target types, - # and two other with prefixes and postfixes to be added to target - # name. We use parallel lists for prefix and postfix (as opposed to - # mapping), because given target type might occur several times, for - # example "H H(%_symbols)". - local m = [ MATCH ([^\\(]*)(\\((.*)%(.*)\\))? : $(e) ] ; - self.target-types += $(m[1]) ; - self.name-prefix += $(m[3]:E="") ; - self.name-postfix += $(m[4]:E="") ; - } - - # Note that 'transform' here, is the same as 'for_each'. - sequence.transform type.validate : $(self.source-types) ; - sequence.transform type.validate : $(self.target-types) ; - } - - ################# End of constructor ################# - - rule id ( ) - { - return $(self.id) ; - } - - # Returns the list of target type the generator accepts. - # - rule source-types ( ) - { - return $(self.source-types) ; - } - - # Returns the list of target types that this generator produces. It is - # assumed to be always the same -- i.e. it can not change depending on some - # provided list of sources. - # - rule target-types ( ) - { - return $(self.target-types) ; - } - - # Returns the required properties for this generator. Properties in returned - # set must be present in build properties if this generator is to be used. - # If result has grist-only element, that build properties must include some - # value of that feature. - # - # XXX: remove this method? - # - rule requirements ( ) - { - return $(self.requirements) ; - } - - rule set-rule-name ( rule-name ) - { - self.rule-name = $(rule-name) ; - } - - rule rule-name ( ) - { - return $(self.rule-name) ; - } - - # Returns a true value if the generator can be run with the specified - # properties. - # - rule match-rank ( property-set-to-match ) - { - # See if generator requirements are satisfied by 'properties'. Treat a - # feature name in requirements (i.e. grist-only element), as matching - # any value of the feature. - local all-requirements = [ requirements ] ; - - local property-requirements feature-requirements ; - for local r in $(all-requirements) - { - if $(r:G=) - { - property-requirements += $(r) ; - } - else - { - feature-requirements += $(r) ; - } - } - - local properties-to-match = [ $(property-set-to-match).raw ] ; - if $(property-requirements) in $(properties-to-match) && - $(feature-requirements) in $(properties-to-match:G) - { - return true ; - } - else - { - return ; - } - } - - # Returns another generator which differs from $(self) in - # - id - # - value to <toolset> feature in properties - # - rule clone ( new-id : new-toolset-properties + ) - { - local g = [ new $(__class__) $(new-id) $(self.composing) : - $(self.source-types) : $(self.target-types-and-names) : - # Note: this does not remove any subfeatures of <toolset> which - # might cause problems. - [ property.change $(self.requirements) : <toolset> ] - $(new-toolset-properties) ] ; - return $(g) ; - } - - # Creates another generator that is the same as $(self), except that if - # 'base' is in target types of $(self), 'type' will in target types of the - # new generator. - # - rule clone-and-change-target-type ( base : type ) - { - local target-types ; - for local t in $(self.target-types-and-names) - { - local m = [ MATCH ([^\\(]*)(\\(.*\\))? : $(t) ] ; - if $(m) = $(base) - { - target-types += $(type)$(m[2]:E="") ; - } - else - { - target-types += $(t) ; - } - } - - local g = [ new $(__class__) $(self.id) $(self.composing) : - $(self.source-types) : $(target-types) : $(self.requirements) ] ; - if $(self.rule-name) - { - $(g).set-rule-name $(self.rule-name) ; - } - return $(g) ; - } - - # Tries to invoke this generator on the given sources. Returns a list of - # generated targets (instances of 'virtual-target') and optionally a set of - # properties to be added to the usage-requirements for all the generated - # targets. Returning nothing from run indicates that the generator was - # unable to create the target. - # - rule run - ( - project # Project for which the targets are generated. - name ? # Used when determining the 'name' attribute for all - # generated targets. See the 'generated-targets' method. - : property-set # Desired properties for generated targets. - : sources + # Source targets. - ) - { - generators.dout [ indent ] " ** generator" $(self.id) ; - generators.dout [ indent ] " composing:" $(self.composing) ; - - if ! $(self.composing) && $(sources[2]) && $(self.source-types[2]) - { - errors.error "Unsupported source/source-type combination" ; - } - - # We do not run composing generators if no name is specified. The reason - # is that composing generator combines several targets, which can have - # different names, and it cannot decide which name to give for produced - # target. Therefore, the name must be passed. - # - # This in effect, means that composing generators are runnable only at - # the top-level of a transformation graph, or if their name is passed - # explicitly. Thus, we dissallow composing generators in the middle. For - # example, the transformation CPP -> OBJ -> STATIC_LIB -> RSP -> EXE - # will not be allowed as the OBJ -> STATIC_LIB generator is composing. - if ! $(self.composing) || $(name) - { - run-really $(project) $(name) : $(property-set) : $(sources) ; - } - } - - rule run-really ( project name ? : property-set : sources + ) - { - # Targets that this generator will consume directly. - local consumed = ; - # Targets that can not be consumed and will be returned as-is. - local bypassed = ; - - if $(self.composing) - { - convert-multiple-sources-to-consumable-types $(project) - : $(property-set) : $(sources) : consumed bypassed ; - } - else - { - convert-to-consumable-types $(project) $(name) : $(property-set) - : $(sources) : : consumed bypassed ; - } - - local result ; - if $(consumed) - { - result = [ construct-result $(consumed) : $(project) $(name) : - $(property-set) ] ; - } - - if $(result) - { - generators.dout [ indent ] " SUCCESS: " $(result) ; - } - else - { - generators.dout [ indent ] " FAILURE" ; - } - generators.dout ; - return $(result) ; - } - - # Constructs the dependency graph to be returned by this generator. - # - rule construct-result - ( - consumed + # Already prepared list of consumable targets. - # Composing generators may receive multiple sources - # all of which will have types matching those in - # $(self.source-types). Non-composing generators with - # multiple $(self.source-types) will receive exactly - # len $(self.source-types) sources with types matching - # those in $(self.source-types). And non-composing - # generators with only a single source type may - # receive multiple sources with all of them of the - # type listed in $(self.source-types). - : project name ? - : property-set # Properties to be used for all actions created here. - ) - { - local result ; - # If this is 1->1 transformation, apply it to all consumed targets in - # order. - if ! $(self.source-types[2]) && ! $(self.composing) - { - for local r in $(consumed) - { - result += [ generated-targets $(r) : $(property-set) : - $(project) $(name) ] ; - } - } - else if $(consumed) - { - result += [ generated-targets $(consumed) : $(property-set) : - $(project) $(name) ] ; - } - return $(result) ; - } - - # Determine target name from fullname (maybe including path components) - # Place optional prefix and postfix around basename - # - rule determine-target-name ( fullname : prefix ? : postfix ? ) - { - # See if we need to add directory to the target name. - local dir = $(fullname:D) ; - local name = $(fullname:B) ; - - name = $(prefix:E=)$(name) ; - name = $(name)$(postfix:E=) ; - - if $(dir) && - # Never append '..' to target path. - ! [ MATCH .*(\\.\\.).* : $(dir) ] - && - ! [ path.is-rooted $(dir) ] - { - # Relative path is always relative to the source - # directory. Retain it, so that users can have files - # with the same in two different subdirectories. - name = $(dir)/$(name) ; - } - return $(name) ; - } - - # Determine the name of the produced target from the names of the sources. - # - rule determine-output-name ( sources + ) - { - # The simple case if when a name of source has single dot. Then, we take - # the part before dot. Several dots can be caused by: - # - using source file like a.host.cpp, or - # - a type whose suffix has a dot. Say, we can type 'host_cpp' with - # extension 'host.cpp'. - # In the first case, we want to take the part up to the last dot. In the - # second case -- not sure, but for now take the part up to the last dot - # too. - name = [ utility.basename [ $(sources[1]).name ] ] ; - - for local s in $(sources[2]) - { - local n2 = [ utility.basename [ $(s).name ] ] ; - if $(n2) != $(name) - { - errors.error "$(self.id): source targets have different names: cannot determine target name" ; - } - } - name = [ determine-target-name [ $(sources[1]).name ] ] ; - return $(name) ; - } - - # Constructs targets that are created after consuming 'sources'. The result - # will be the list of virtual-target, which has the same length as the - # 'target-types' attribute and with corresponding types. - # - # When 'name' is empty, all source targets must have the same 'name' - # attribute value, which will be used instead of the 'name' argument. - # - # The 'name' attribute value for each generated target will be equal to - # the 'name' parameter if there is no name pattern for this type. Otherwise, - # the '%' symbol in the name pattern will be replaced with the 'name' - # parameter to obtain the 'name' attribute. - # - # For example, if targets types are T1 and T2 (with name pattern "%_x"), - # suffixes for T1 and T2 are .t1 and .t2, and source is foo.z, then created - # files would be "foo.t1" and "foo_x.t2". The 'name' attribute actually - # determines the basename of a file. - # - # Note that this pattern mechanism has nothing to do with implicit patterns - # in make. It is a way to produce a target whose name is different than the - # name of its source. - # - rule generated-targets ( sources + : property-set : project name ? ) - { - if ! $(name) - { - name = [ determine-output-name $(sources) ] ; - } - - # Assign an action for each target. - local action = [ action-class ] ; - local a = [ class.new $(action) $(sources) : $(self.rule-name) : - $(property-set) ] ; - - # Create generated target for each target type. - local targets ; - local pre = $(self.name-prefix) ; - local post = $(self.name-postfix) ; - for local t in $(self.target-types) - { - local generated-name = $(pre[1])$(name:BS)$(post[1]) ; - generated-name = $(generated-name:R=$(name:D)) ; - pre = $(pre[2-]) ; - post = $(post[2-]) ; - - targets += [ class.new file-target $(generated-name) : $(t) : - $(project) : $(a) ] ; - } - - return [ sequence.transform virtual-target.register : $(targets) ] ; - } - - # Attempts to convert 'sources' to targets of types that this generator can - # handle. The intention is to produce the set of targets that can be used - # when the generator is run. - # - rule convert-to-consumable-types - ( - project name ? - : property-set - : sources + - : only-one ? # Convert 'source' to only one of the source types. If - # there is more that one possibility, report an error. - : consumed-var # Name of the variable which receives all targets which - # can be consumed. - bypassed-var # Name of the variable which receives all targets which - # can not be consumed. - ) - { - # We are likely to be passed 'consumed' and 'bypassed' var names. Use - # '_' to avoid name conflicts. - local _consumed ; - local _bypassed ; - local missing-types ; - - if $(sources[2]) - { - # Do not know how to handle several sources yet. Just try to pass - # the request to other generator. - missing-types = $(self.source-types) ; - } - else - { - consume-directly $(sources) : _consumed : missing-types ; - } - - # No need to search for transformation if some source type has consumed - # source and no more source types are needed. - if $(only-one) && $(_consumed) - { - missing-types = ; - } - - # TODO: we should check that only one source type if create of - # 'only-one' is true. - # TODO: consider if consumed/bypassed separation should be done by - # 'construct-types'. - - if $(missing-types) - { - local transformed = [ generators.construct-types $(project) $(name) - : $(missing-types) : $(property-set) : $(sources) ] ; - - # Add targets of right type to 'consumed'. Add others to 'bypassed'. - # The 'generators.construct' rule has done its best to convert - # everything to the required type. There is no need to rerun it on - # targets of different types. - - # NOTE: ignoring usage requirements. - for local t in $(transformed[2-]) - { - if [ $(t).type ] in $(missing-types) - { - _consumed += $(t) ; - } - else - { - _bypassed += $(t) ; - } - } - } - - _consumed = [ sequence.unique $(_consumed) ] ; - _bypassed = [ sequence.unique $(_bypassed) ] ; - - # Remove elements of '_bypassed' that are in '_consumed'. - - # Suppose the target type of current generator, X is produced from X_1 - # and X_2, which are produced from Y by one generator. When creating X_1 - # from Y, X_2 will be added to 'bypassed'. Likewise, when creating X_2 - # from Y, X_1 will be added to 'bypassed', but they are also in - # 'consumed'. We have to remove them from bypassed, so that generators - # up the call stack do not try to convert them. - - # In this particular case, X_1 instance in 'consumed' and X_1 instance - # in 'bypassed' will be the same: because they have the same source and - # action name, and 'virtual-target.register' will not allow two - # different instances. Therefore, it is OK to use 'set.difference'. - - _bypassed = [ set.difference $(_bypassed) : $(_consumed) ] ; - - $(consumed-var) += $(_consumed) ; - $(bypassed-var) += $(_bypassed) ; - } - - # Converts several files to consumable types. Called for composing - # generators only. - # - rule convert-multiple-sources-to-consumable-types ( project : property-set : - sources * : consumed-var bypassed-var ) - { - # We process each source one-by-one, trying to convert it to a usable - # type. - for local source in $(sources) - { - local _c ; - local _b ; - # TODO: need to check for failure on each source. - convert-to-consumable-types $(project) : $(property-set) : $(source) - : true : _c _b ; - if ! $(_c) - { - generators.dout [ indent ] " failed to convert " $(source) ; - } - $(consumed-var) += $(_c) ; - $(bypassed-var) += $(_b) ; - } - } - - rule consume-directly ( source : consumed-var : missing-types-var ) - { - local real-source-type = [ $(source).type ] ; - - # If there are no source types, we can consume anything. - local source-types = $(self.source-types) ; - source-types ?= $(real-source-type) ; - - for local st in $(source-types) - { - # The 'source' if of the right type already. - if $(real-source-type) = $(st) || [ type.is-derived - $(real-source-type) $(st) ] - { - $(consumed-var) += $(source) ; - } - else - { - $(missing-types-var) += $(st) ; - } - } - } - - # Returns the class to be used to actions. Default implementation returns - # "action". - # - rule action-class ( ) - { - return "action" ; - } -} - - -# Registers a new generator instance 'g'. -# -rule register ( g ) -{ - .all-generators += $(g) ; - - # A generator can produce several targets of the same type. We want unique - # occurrence of that generator in .generators.$(t) in that case, otherwise, - # it will be tried twice and we will get a false ambiguity. - for local t in [ sequence.unique [ $(g).target-types ] ] - { - .generators.$(t) += $(g) ; - } - - # Update the set of generators for toolset. - - # TODO: should we check that generator with this id is not already - # registered. For example, the fop.jam module intentionally declared two - # generators with the same id, so such check will break it. - local id = [ $(g).id ] ; - - # Some generators have multiple periods in their name, so a simple $(id:S=) - # will not generate the right toolset name. E.g. if id = gcc.compile.c++, - # then .generators-for-toolset.$(id:S=) will append to - # .generators-for-toolset.gcc.compile, which is a separate value from - # .generators-for-toolset.gcc. Correcting this makes generator inheritance - # work properly. See also inherit-generators in the toolset module. - local base = $(id) ; - while $(base:S) - { - base = $(base:B) ; - } - .generators-for-toolset.$(base) += $(g) ; - - - # After adding a new generator that can construct new target types, we need - # to clear the related cached viable source target type information for - # constructing a specific target type or using a specific generator. Cached - # viable source target type lists affected by this are those containing any - # of the target types constructed by the new generator or any of their base - # target types. - # - # A more advanced alternative to clearing that cached viable source target - # type information would be to expand it with additional source types or - # even better - mark it as needing to be expanded on next use. - # - # Also see the http://thread.gmane.org/gmane.comp.lib.boost.build/19077 - # mailing list thread for an even more advanced idea of how we could convert - # Boost Build's Jamfile processing, target selection and generator selection - # into separate steps which would prevent these caches from ever being - # invalidated. - # - # For now we just clear all the cached viable source target type information - # that does not simply state 'all types' and may implement a more detailed - # algorithm later on if it becomes needed. - - invalidate-extendable-viable-source-target-type-cache ; -} - - -# Creates a new non-composing 'generator' class instance and registers it. -# Returns the created instance. Rationale: the instance is returned so that it -# is possible to first register a generator and then call its 'run' method, -# bypassing the whole generator selection process. -# -rule register-standard ( id : source-types * : target-types + : requirements * ) -{ - local g = [ new generator $(id) : $(source-types) : $(target-types) : - $(requirements) ] ; - register $(g) ; - return $(g) ; -} - - -# Creates a new composing 'generator' class instance and registers it. -# -rule register-composing ( id : source-types * : target-types + : requirements * - ) -{ - local g = [ new generator $(id) true : $(source-types) : $(target-types) : - $(requirements) ] ; - register $(g) ; - return $(g) ; -} - - -# Returns all generators belonging to the given 'toolset', i.e. whose ids are -# '$(toolset).<something>'. -# -rule generators-for-toolset ( toolset ) -{ - return $(.generators-for-toolset.$(toolset)) ; -} - - -# Make generator 'overrider-id' be preferred to 'overridee-id'. If, when -# searching for generators that could produce a target of a certain type, both -# those generators are among viable generators, the overridden generator is -# immediately discarded. -# -# The overridden generators are discarded immediately after computing the list -# of viable generators but before running any of them. -# -rule override ( overrider-id : overridee-id ) -{ - .override.$(overrider-id) += $(overridee-id) ; -} - - -# Returns a list of source type which can possibly be converted to 'target-type' -# by some chain of generator invocation. -# -# More formally, takes all generators for 'target-type' and returns a union of -# source types for those generators and result of calling itself recursively on -# source types. -# -# Returns '*' in case any type should be considered a viable source type for the -# given type. -# -local rule viable-source-types-real ( target-type ) -{ - local result ; - - # 't0' is the initial list of target types we need to process to get a list - # of their viable source target types. New target types will not be added to - # this list. - local t0 = [ type.all-bases $(target-type) ] ; - - # 't' is the list of target types which have not yet been processed to get a - # list of their viable source target types. This list will get expanded as - # we locate more target types to process. - local t = $(t0) ; - - while $(t) - { - # Find all generators for the current type. Unlike - # 'find-viable-generators' we do not care about the property-set. - local generators = $(.generators.$(t[1])) ; - t = $(t[2-]) ; - - while $(generators) - { - local g = $(generators[1]) ; - generators = $(generators[2-]) ; - - if ! [ $(g).source-types ] - { - # Empty source types -- everything can be accepted. - result = * ; - # This will terminate this loop. - generators = ; - # This will terminate the outer loop. - t = ; - } - - for local source-type in [ $(g).source-types ] - { - if ! $(source-type) in $(result) - { - # If a generator accepts a 'source-type' it will also - # happily accept any type derived from it. - for local n in [ type.all-derived $(source-type) ] - { - if ! $(n) in $(result) - { - # Here there is no point in adding target types to - # the list of types to process in case they are or - # have already been on that list. We optimize this - # check by realizing that we only need to avoid the - # original target type's base types. Other target - # types that are or have been on the list of target - # types to process have been added to the 'result' - # list as well and have thus already been eliminated - # by the previous if. - if ! $(n) in $(t0) - { - t += $(n) ; - } - result += $(n) ; - } - } - } - } - } - } - - return $(result) ; -} - - -# Helper rule, caches the result of 'viable-source-types-real'. -# -rule viable-source-types ( target-type ) -{ - local key = .vst.$(target-type) ; - if ! $($(key)) - { - .vst-cached-types += $(target-type) ; - local v = [ viable-source-types-real $(target-type) ] ; - if ! $(v) - { - v = none ; - } - $(key) = $(v) ; - } - - if $($(key)) != none - { - return $($(key)) ; - } -} - - -# Returns the list of source types, which, when passed to 'run' method of -# 'generator', has some change of being eventually used (probably after -# conversion by other generators). -# -# Returns '*' in case any type should be considered a viable source type for the -# given generator. -# -rule viable-source-types-for-generator-real ( generator ) -{ - local source-types = [ $(generator).source-types ] ; - if ! $(source-types) - { - # If generator does not specify any source types, it might be a special - # generator like builtin.lib-generator which just relays to other - # generators. Return '*' to indicate that any source type is possibly - # OK, since we do not know for sure. - return * ; - } - else - { - local result ; - while $(source-types) - { - local s = $(source-types[1]) ; - source-types = $(source-types[2-]) ; - local viable-sources = [ generators.viable-source-types $(s) ] ; - if $(viable-sources) = * - { - result = * ; - source-types = ; # Terminate the loop. - } - else - { - result += [ type.all-derived $(s) ] $(viable-sources) ; - } - } - return [ sequence.unique $(result) ] ; - } -} - - -# Helper rule, caches the result of 'viable-source-types-for-generator'. -# -local rule viable-source-types-for-generator ( generator ) -{ - local key = .vstg.$(generator) ; - if ! $($(key)) - { - .vstg-cached-generators += $(generator) ; - local v = [ viable-source-types-for-generator-real $(generator) ] ; - if ! $(v) - { - v = none ; - } - $(key) = $(v) ; - } - - if $($(key)) != none - { - return $($(key)) ; - } -} - - -# Returns usage requirements + list of created targets. -# -local rule try-one-generator-really ( project name ? : generator : target-type - : property-set : sources * ) -{ - local targets = - [ $(generator).run $(project) $(name) : $(property-set) : $(sources) ] ; - - local usage-requirements ; - local success ; - - generators.dout [ indent ] returned $(targets) ; - - if $(targets) - { - success = true ; - - if [ class.is-a $(targets[1]) : property-set ] - { - usage-requirements = $(targets[1]) ; - targets = $(targets[2-]) ; - } - else - { - usage-requirements = [ property-set.empty ] ; - } - } - - generators.dout [ indent ] " generator" [ $(generator).id ] " spawned " ; - generators.dout [ indent ] " " $(targets) ; - if $(usage-requirements) - { - generators.dout [ indent ] " with usage requirements:" $(x) ; - } - - if $(success) - { - return $(usage-requirements) $(targets) ; - } -} - - -# Checks if generator invocation can be pruned, because it is guaranteed to -# fail. If so, quickly returns an empty list. Otherwise, calls -# try-one-generator-really. -# -local rule try-one-generator ( project name ? : generator : target-type - : property-set : sources * ) -{ - local source-types ; - for local s in $(sources) - { - source-types += [ $(s).type ] ; - } - local viable-source-types = [ viable-source-types-for-generator $(generator) - ] ; - - if $(source-types) && $(viable-source-types) != * && - ! [ set.intersection $(source-types) : $(viable-source-types) ] - { - local id = [ $(generator).id ] ; - generators.dout [ indent ] " ** generator '$(id)' pruned" ; - #generators.dout [ indent ] "source-types" '$(source-types)' ; - #generators.dout [ indent ] "viable-source-types" '$(viable-source-types)' ; - } - else - { - return [ try-one-generator-really $(project) $(name) : $(generator) : - $(target-type) : $(property-set) : $(sources) ] ; - } -} - - -rule construct-types ( project name ? : target-types + : property-set - : sources + ) -{ - local result ; - local matched-types ; - local usage-requirements = [ property-set.empty ] ; - for local t in $(target-types) - { - local r = [ construct $(project) $(name) : $(t) : $(property-set) : - $(sources) ] ; - if $(r) - { - usage-requirements = [ $(usage-requirements).add $(r[1]) ] ; - result += $(r[2-]) ; - matched-types += $(t) ; - } - } - # TODO: have to introduce parameter controlling if several types can be - # matched and add appropriate checks. - - # TODO: need to review the documentation for 'construct' to see if it should - # return $(source) even if nothing can be done with it. Currents docs seem - # to imply that, contrary to the behaviour. - if $(result) - { - return $(usage-requirements) $(result) ; - } - else - { - return $(usage-requirements) $(sources) ; - } -} - - -# Ensures all 'targets' have their type. If this is not so, exists with error. -# -local rule ensure-type ( targets * ) -{ - for local t in $(targets) - { - if ! [ $(t).type ] - { - errors.error "target" [ $(t).str ] "has no type" ; - } - } -} - - -# Returns generators which can be used to construct target of specified type -# with specified properties. Uses the following algorithm: -# - iterates over requested target-type and all its bases (in the order returned -# by type.all-bases). -# - for each type find all generators that generate that type and whose -# requirements are satisfied by properties. -# - if the set of generators is not empty, returns that set. -# -# Note: this algorithm explicitly ignores generators for base classes if there -# is at least one generator for the requested target-type. -# -local rule find-viable-generators-aux ( target-type : property-set ) -{ - # Select generators that can create the required target type. - local viable-generators = ; - local generator-rank = ; - - import type ; - local t = [ type.all-bases $(target-type) ] ; - - generators.dout [ indent ] find-viable-generators target-type= $(target-type) - property-set= [ $(property-set).as-path ] ; - - # Get the list of generators for the requested type. If no generator is - # registered, try base type, and so on. - local generators ; - while $(t[1]) - { - generators.dout [ indent ] "trying type" $(t[1]) ; - if $(.generators.$(t[1])) - { - generators.dout [ indent ] "there are generators for this type" ; - generators = $(.generators.$(t[1])) ; - - if $(t[1]) != $(target-type) - { - # We are here because there were no generators found for - # target-type but there are some generators for its base type. - # We will try to use them, but they will produce targets of - # base type, not of 'target-type'. So, we clone the generators - # and modify the list of target types. - local generators2 ; - for local g in $(generators) - { - # generators.register adds a generator to the list of - # generators for toolsets, which is a bit strange, but - # should work. That list is only used when inheriting a - # toolset, which should have been done before running - # generators. - generators2 += [ $(g).clone-and-change-target-type $(t[1]) : - $(target-type) ] ; - generators.register $(generators2[-1]) ; - } - generators = $(generators2) ; - } - t = ; - } - t = $(t[2-]) ; - } - - for local g in $(generators) - { - generators.dout [ indent ] "trying generator" [ $(g).id ] "(" [ $(g).source-types ] -> [ $(g).target-types ] ")" ; - - local m = [ $(g).match-rank $(property-set) ] ; - if $(m) - { - generators.dout [ indent ] " is viable" ; - viable-generators += $(g) ; - } - } - - return $(viable-generators) ; -} - - -rule find-viable-generators ( target-type : property-set ) -{ - local key = $(target-type).$(property-set) ; - local l = $(.fv.$(key)) ; - if ! $(l) - { - l = [ find-viable-generators-aux $(target-type) : $(property-set) ] ; - if ! $(l) - { - l = none ; - } - .fv.$(key) = $(l) ; - } - - if $(l) = none - { - l = ; - } - - local viable-generators ; - for local g in $(l) - { - # Avoid trying the same generator twice on different levels. - if ! $(g) in $(.active-generators) - { - viable-generators += $(g) ; - } - else - { - generators.dout [ indent ] " generator " [ $(g).id ] "is active, discaring" ; - } - } - - # Generators which override 'all'. - local all-overrides ; - # Generators which are overriden. - local overriden-ids ; - for local g in $(viable-generators) - { - local id = [ $(g).id ] ; - local this-overrides = $(.override.$(id)) ; - overriden-ids += $(this-overrides) ; - if all in $(this-overrides) - { - all-overrides += $(g) ; - } - } - if $(all-overrides) - { - viable-generators = $(all-overrides) ; - } - local result ; - for local g in $(viable-generators) - { - if ! [ $(g).id ] in $(overriden-ids) - { - result += $(g) ; - } - } - - return $(result) ; -} - - -.construct-stack = ; - - -# Attempts to construct a target by finding viable generators, running them and -# selecting the dependency graph. -# -local rule construct-really ( project name ? : target-type : property-set : - sources * ) -{ - viable-generators = [ find-viable-generators $(target-type) : - $(property-set) ] ; - - generators.dout [ indent ] "*** " [ sequence.length $(viable-generators) ] - " viable generators" ; - - local result ; - local generators-that-succeeded ; - for local g in $(viable-generators) - { - # This variable will be restored on exit from this scope. - local .active-generators = $(g) $(.active-generators) ; - - local r = [ try-one-generator $(project) $(name) : $(g) : $(target-type) - : $(property-set) : $(sources) ] ; - - if $(r) - { - generators-that-succeeded += $(g) ; - if $(result) - { - ECHO "Error: ambiguity found when searching for best transformation" ; - ECHO "Trying to produce type '$(target-type)' from: " ; - for local s in $(sources) - { - ECHO " - " [ $(s).str ] ; - } - ECHO "Generators that succeeded:" ; - for local g in $(generators-that-succeeded) - { - ECHO " - " [ $(g).id ] ; - } - ECHO "First generator produced: " ; - for local t in $(result[2-]) - { - ECHO " - " [ $(t).str ] ; - } - ECHO "Second generator produced: " ; - for local t in $(r[2-]) - { - ECHO " - " [ $(t).str ] ; - } - EXIT ; - } - else - { - result = $(r) ; - } - } - } - - return $(result) ; -} - - -# Attempts to create a target of 'target-type' with 'properties' from 'sources'. -# The 'sources' are treated as a collection of *possible* ingridients, i.e. -# there is no obligation to consume them all. -# -# Returns a list of targets. When this invocation is first instance of -# 'construct' in stack, returns only targets of requested 'target-type', -# otherwise, returns also unused sources and additionally generated targets. -# -# If 'top-level' is set, does not suppress generators that are already -# used in the stack. This may be useful in cases where a generator -# has to build a metatargets -- for example a target corresponding to -# built tool. -# -rule construct ( project name ? : target-type : property-set * : sources * : top-level ? ) -{ - local saved-stack ; - if $(top-level) - { - saved-active = $(.active-generators) ; - .active-generators = ; - } - - if (.construct-stack) - { - ensure-type $(sources) ; - } - - .construct-stack += 1 ; - - increase-indent ; - - if $(.debug) - { - generators.dout [ indent ] "*** construct" $(target-type) ; - - for local s in $(sources) - { - generators.dout [ indent ] " from" $(s) ; - } - generators.dout [ indent ] " properties:" [ $(property-set).raw ] ; - } - - local result = [ construct-really $(project) $(name) : $(target-type) : - $(property-set) : $(sources) ] ; - - decrease-indent ; - - .construct-stack = $(.construct-stack[2-]) ; - - if $(top-level) - { - .active-generators = $(saved-active) ; - } - - return $(result) ; -} - -# Given 'result', obtained from some generator or generators.construct, adds -# 'raw-properties' as usage requirements to it. If result already contains usage -# requirements -- that is the first element of result of an instance of the -# property-set class, the existing usage requirements and 'raw-properties' are -# combined. -# -rule add-usage-requirements ( result * : raw-properties * ) -{ - if $(result) - { - if [ class.is-a $(result[1]) : property-set ] - { - return [ $(result[1]).add-raw $(raw-properties) ] $(result[2-]) ; - } - else - { - return [ property-set.create $(raw-properties) ] $(result) ; - } - } -} - -rule dump ( ) -{ - for local g in $(.all-generators) - { - ECHO [ $(g).id ] ":" [ $(g).source-types ] -> [ $(g).target-types ] ; - } -} - diff --git a/jam-files/boost-build/build/generators.py b/jam-files/boost-build/build/generators.py deleted file mode 100644 index 2c59f7ca..00000000 --- a/jam-files/boost-build/build/generators.py +++ /dev/null @@ -1,1089 +0,0 @@ -# Status: being ported by Vladimir Prus -# Base revision: 48649 -# TODO: replace the logging with dout - -# Copyright Vladimir Prus 2002. -# Copyright Rene Rivera 2006. -# -# Distributed under the Boost Software License, Version 1.0. -# (See accompanying file LICENSE_1_0.txt or copy at -# http://www.boost.org/LICENSE_1_0.txt) - -# Manages 'generators' --- objects which can do transformation between different -# target types and contain algorithm for finding transformation from sources -# to targets. -# -# The main entry point to this module is generators.construct rule. It is given -# a list of source targets, desired target type and a set of properties. -# It starts by selecting 'viable generators', which have any chances of producing -# the desired target type with the required properties. Generators are ranked and -# a set of most specific ones is selected. -# -# The most specific generators have their 'run' methods called, with the properties -# and list of sources. Each one selects target which can be directly consumed, and -# tries to convert the remaining ones to the types it can consume. This is done -# by recursively calling 'construct' with all consumable types. -# -# If the generator has collected all the targets it needs, it creates targets -# corresponding to result, and returns it. When all generators have been run, -# results of one of them are selected and returned as result. -# -# It's quite possible that 'construct' returns more targets that it was asked for. -# For example, it was asked to target type EXE, but the only found generators produces -# both EXE and TDS (file with debug) information. The extra target will be returned. -# -# Likewise, when generator tries to convert sources to consumable types, it can get -# more targets that it was asked for. The question is what to do with extra targets. -# Boost.Build attempts to convert them to requested types, and attempts as early as -# possible. Specifically, this is done after invoking each generator. (Later I'll -# document the rationale for trying extra target conversion at that point). -# -# That early conversion is not always desirable. Suppose a generator got a source of -# type Y and must consume one target of type X_1 and one target of type X_2. -# When converting Y to X_1 extra target of type Y_2 is created. We should not try to -# convert it to type X_1, because if we do so, the generator will get two targets -# of type X_1, and will be at loss as to which one to use. Because of that, the -# 'construct' rule has a parameter, telling if multiple targets can be returned. If -# the parameter is false, conversion of extra targets is not performed. - - -import re -import cStringIO -import os.path - -from virtual_target import Subvariant -import virtual_target, type, property_set, property -from b2.util.logger import * -from b2.util.utility import * -from b2.util import set -from b2.util.sequence import unique -import b2.util.sequence as sequence -from b2.manager import get_manager -import b2.build.type - -def reset (): - """ Clear the module state. This is mainly for testing purposes. - """ - global __generators, __type_to_generators, __generators_for_toolset, __construct_stack - global __overrides, __active_generators - global __viable_generators_cache, __viable_source_types_cache - global __vstg_cached_generators, __vst_cached_types - - __generators = {} - __type_to_generators = {} - __generators_for_toolset = {} - __overrides = {} - - # TODO: can these be global? - __construct_stack = [] - __viable_generators_cache = {} - __viable_source_types_cache = {} - __active_generators = [] - - __vstg_cached_generators = [] - __vst_cached_types = [] - -reset () - -_re_separate_types_prefix_and_postfix = re.compile ('([^\\(]*)(\\((.*)%(.*)\\))?') -_re_match_type = re.compile('([^\\(]*)(\\(.*\\))?') - - -__debug = None -__indent = "" - -def debug(): - global __debug - if __debug is None: - __debug = "--debug-generators" in bjam.variable("ARGV") - return __debug - -def increase_indent(): - global __indent - __indent += " " - -def decrease_indent(): - global __indent - __indent = __indent[0:-4] - - -# Updated cached viable source target type information as needed after a new -# derived target type gets added. This is needed because if a target type is a -# viable source target type for some generator then all of the target type's -# derived target types are automatically viable as source target types for the -# same generator. Does nothing if a non-derived target type is passed to it. -# -def update_cached_information_with_a_new_type(type): - - base_type = b2.build.type.base(type) - - if base_type: - for g in __vstg_cached_generators: - if base_type in __viable_source_types_cache.get(g, []): - __viable_source_types_cache[g].append(type) - - for t in __vst_cached_types: - if base_type in __viable_source_types_cache.get(t, []): - __viable_source_types_cache[t].append(type) - -# Clears cached viable source target type information except for target types -# and generators with all source types listed as viable. Should be called when -# something invalidates those cached values by possibly causing some new source -# types to become viable. -# -def invalidate_extendable_viable_source_target_type_cache(): - - global __vstg_cached_generators - generators_with_cached_source_types = __vstg_cached_generators - __vstg_cached_generators = [] - - for g in generators_with_cached_source_types: - if __viable_source_types_cache.has_key(g): - if __viable_source_types_cache[g] == ["*"]: - __vstg_cached_generators.append(g) - else: - del __viable_source_types_cache[g] - - global __vst_cached_types - types_with_cached_sources_types = __vst_cached_types - __vst_cached_types = [] - for t in types_with_cached_sources_types: - if __viable_source_types_cache.has_key(t): - if __viable_source_types_cache[t] == ["*"]: - __vst_cached_types.append(t) - else: - del __viable_source_types_cache[t] - -def dout(message): - if debug(): - print __indent + message - -class Generator: - """ Creates a generator. - manager: the build manager. - id: identifies the generator - - rule: the rule which sets up build actions. - - composing: whether generator processes each source target in - turn, converting it to required types. - Ordinary generators pass all sources together to - recusrive generators.construct_types call. - - source_types (optional): types that this generator can handle - - target_types_and_names: types the generator will create and, optionally, names for - created targets. Each element should have the form - type["(" name-pattern ")"] - for example, obj(%_x). Name of generated target will be found - by replacing % with the name of source, provided explicit name - was not specified. - - requirements (optional) - - NOTE: all subclasses must have a similar signature for clone to work! - """ - def __init__ (self, id, composing, source_types, target_types_and_names, requirements = []): - assert(not isinstance(source_types, str)) - assert(not isinstance(target_types_and_names, str)) - self.id_ = id - self.composing_ = composing - self.source_types_ = source_types - self.target_types_and_names_ = target_types_and_names - self.requirements_ = requirements - - self.target_types_ = [] - self.name_prefix_ = [] - self.name_postfix_ = [] - - for e in target_types_and_names: - # Create three parallel lists: one with the list of target types, - # and two other with prefixes and postfixes to be added to target - # name. We use parallel lists for prefix and postfix (as opposed - # to mapping), because given target type might occur several times, - # for example "H H(%_symbols)". - m = _re_separate_types_prefix_and_postfix.match (e) - - if not m: - raise BaseException ("Invalid type and name '%s' in declaration of type '%s'" % (e, id)) - - target_type = m.group (1) - if not target_type: target_type = '' - prefix = m.group (3) - if not prefix: prefix = '' - postfix = m.group (4) - if not postfix: postfix = '' - - self.target_types_.append (target_type) - self.name_prefix_.append (prefix) - self.name_postfix_.append (postfix) - - for x in self.source_types_: - type.validate (x) - - for x in self.target_types_: - type.validate (x) - - def clone (self, new_id, new_toolset_properties): - """ Returns another generator which differers from $(self) in - - id - - value to <toolset> feature in properties - """ - return self.__class__ (new_id, - self.composing_, - self.source_types_, - self.target_types_and_names_, - # Note: this does not remove any subfeatures of <toolset> - # which might cause problems - property.change (self.requirements_, '<toolset>') + new_toolset_properties) - - def clone_and_change_target_type(self, base, type): - """Creates another generator that is the same as $(self), except that - if 'base' is in target types of $(self), 'type' will in target types - of the new generator.""" - target_types = [] - for t in self.target_types_and_names_: - m = _re_match_type.match(t) - assert m - - if m.group(1) == base: - if m.group(2): - target_types.append(type + m.group(2)) - else: - target_types.append(type) - else: - target_types.append(t) - - return self.__class__(self.id_, self.composing_, - self.source_types_, - target_types, - self.requirements_) - - - def id(self): - return self.id_ - - def source_types (self): - """ Returns the list of target type the generator accepts. - """ - return self.source_types_ - - def target_types (self): - """ Returns the list of target types that this generator produces. - It is assumed to be always the same -- i.e. it cannot change depending - list of sources. - """ - return self.target_types_ - - def requirements (self): - """ Returns the required properties for this generator. Properties - in returned set must be present in build properties if this - generator is to be used. If result has grist-only element, - that build properties must include some value of that feature. - """ - return self.requirements_ - - def match_rank (self, ps): - """ Returns true if the generator can be run with the specified - properties. - """ - # See if generator's requirements are satisfied by - # 'properties'. Treat a feature name in requirements - # (i.e. grist-only element), as matching any value of the - # feature. - all_requirements = self.requirements () - - property_requirements = [] - feature_requirements = [] - # This uses strings because genenator requirements allow - # the '<feature>' syntax without value and regular validation - # is not happy about that. - for r in all_requirements: - if get_value (r): - property_requirements.append (r) - - else: - feature_requirements.append (r) - - return all(ps.get(get_grist(s)) == [get_value(s)] for s in property_requirements) \ - and all(ps.get(get_grist(s)) for s in feature_requirements) - - def run (self, project, name, prop_set, sources): - """ Tries to invoke this generator on the given sources. Returns a - list of generated targets (instances of 'virtual-target'). - - project: Project for which the targets are generated. - - name: Determines the name of 'name' attribute for - all generated targets. See 'generated_targets' method. - - prop_set: Desired properties for generated targets. - - sources: Source targets. - """ - - if project.manager ().logger ().on (): - project.manager ().logger ().log (__name__, " generator '%s'" % self.id_) - project.manager ().logger ().log (__name__, " composing: '%s'" % self.composing_) - - if not self.composing_ and len (sources) > 1 and len (self.source_types_) > 1: - raise BaseException ("Unsupported source/source_type combination") - - # We don't run composing generators if no name is specified. The reason - # is that composing generator combines several targets, which can have - # different names, and it cannot decide which name to give for produced - # target. Therefore, the name must be passed. - # - # This in effect, means that composing generators are runnable only - # at top-level of transofrmation graph, or if name is passed explicitly. - # Thus, we dissallow composing generators in the middle. For example, the - # transofrmation CPP -> OBJ -> STATIC_LIB -> RSP -> EXE won't be allowed - # (the OBJ -> STATIC_LIB generator is composing) - if not self.composing_ or name: - return self.run_really (project, name, prop_set, sources) - else: - return [] - - def run_really (self, project, name, prop_set, sources): - - # consumed: Targets that this generator will consume directly. - # bypassed: Targets that can't be consumed and will be returned as-is. - - if self.composing_: - (consumed, bypassed) = self.convert_multiple_sources_to_consumable_types (project, prop_set, sources) - else: - (consumed, bypassed) = self.convert_to_consumable_types (project, name, prop_set, sources) - - result = [] - if consumed: - result = self.construct_result (consumed, project, name, prop_set) - result.extend (bypassed) - - if result: - if project.manager ().logger ().on (): - project.manager ().logger ().log (__name__, " SUCCESS: ", result) - - else: - project.manager ().logger ().log (__name__, " FAILURE") - - return result - - def construct_result (self, consumed, project, name, prop_set): - """ Constructs the dependency graph that will be returned by this - generator. - consumed: Already prepared list of consumable targets - If generator requires several source files will contain - exactly len $(self.source_types_) targets with matching types - Otherwise, might contain several targets with the type of - self.source_types_ [0] - project: - name: - prop_set: Properties to be used for all actions create here - """ - result = [] - # If this is 1->1 transformation, apply it to all consumed targets in order. - if len (self.source_types_) < 2 and not self.composing_: - - for r in consumed: - result.extend (self.generated_targets ([r], prop_set, project, name)) - - else: - - if consumed: - result.extend (self.generated_targets (consumed, prop_set, project, name)) - - return result - - def determine_target_name(self, fullname): - # Determine target name from fullname (maybe including path components) - # Place optional prefix and postfix around basename - - dir = os.path.dirname(fullname) - name = os.path.basename(fullname) - - if dir and not ".." in dir and not os.path.isabs(dir): - # Relative path is always relative to the source - # directory. Retain it, so that users can have files - # with the same in two different subdirectories. - name = dir + "/" + name - - return name - - def determine_output_name(self, sources): - """Determine the name of the produced target from the - names of the sources.""" - - # The simple case if when a name - # of source has single dot. Then, we take the part before - # dot. Several dots can be caused by: - # - Using source file like a.host.cpp - # - A type which suffix has a dot. Say, we can - # type 'host_cpp' with extension 'host.cpp'. - # In the first case, we want to take the part till the last - # dot. In the second case -- no sure, but for now take - # the part till the last dot too. - name = os.path.splitext(sources[0].name())[0] - - for s in sources[1:]: - n2 = os.path.splitext(s.name()) - if n2 != name: - get_manager().errors()( - "%s: source targets have different names: cannot determine target name" - % (self.id_)) - - # Names of sources might include directory. We should strip it. - return self.determine_target_name(sources[0].name()) - - - def generated_targets (self, sources, prop_set, project, name): - """ Constructs targets that are created after consuming 'sources'. - The result will be the list of virtual-target, which the same length - as 'target_types' attribute and with corresponding types. - - When 'name' is empty, all source targets must have the same value of - the 'name' attribute, which will be used instead of the 'name' argument. - - The value of 'name' attribute for each generated target will be equal to - the 'name' parameter if there's no name pattern for this type. Otherwise, - the '%' symbol in the name pattern will be replaced with the 'name' parameter - to obtain the 'name' attribute. - - For example, if targets types are T1 and T2(with name pattern "%_x"), suffixes - for T1 and T2 are .t1 and t2, and source if foo.z, then created files would - be "foo.t1" and "foo_x.t2". The 'name' attribute actually determined the - basename of a file. - - Note that this pattern mechanism has nothing to do with implicit patterns - in make. It's a way to produce target which name is different for name of - source. - """ - if not name: - name = self.determine_output_name(sources) - - # Assign an action for each target - action = self.action_class() - a = action(project.manager(), sources, self.id_, prop_set) - - # Create generated target for each target type. - targets = [] - pre = self.name_prefix_ - post = self.name_postfix_ - for t in self.target_types_: - basename = os.path.basename(name) - idx = basename.find(".") - if idx != -1: - basename = basename[:idx] - generated_name = pre[0] + basename + post[0] - generated_name = os.path.join(os.path.dirname(name), generated_name) - pre = pre[1:] - post = post[1:] - - targets.append(virtual_target.FileTarget(generated_name, t, project, a)) - - return [ project.manager().virtual_targets().register(t) for t in targets ] - - def convert_to_consumable_types (self, project, name, prop_set, sources, only_one=False): - """ Attempts to convert 'source' to the types that this generator can - handle. The intention is to produce the set of targets can should be - used when generator is run. - only_one: convert 'source' to only one of source types - if there's more that one possibility, report an - error. - - Returns a pair: - consumed: all targets that can be consumed. - bypassed: all targets that cannot be consumed. - """ - consumed = [] - bypassed = [] - missing_types = [] - - if len (sources) > 1: - # Don't know how to handle several sources yet. Just try - # to pass the request to other generator - missing_types = self.source_types_ - - else: - (c, m) = self.consume_directly (sources [0]) - consumed += c - missing_types += m - - # No need to search for transformation if - # some source type has consumed source and - # no more source types are needed. - if only_one and consumed: - missing_types = [] - - #TODO: we should check that only one source type - #if create of 'only_one' is true. - # TODO: consider if consuned/bypassed separation should - # be done by 'construct_types'. - - if missing_types: - transformed = construct_types (project, name, missing_types, prop_set, sources) - - # Add targets of right type to 'consumed'. Add others to - # 'bypassed'. The 'generators.construct' rule has done - # its best to convert everything to the required type. - # There's no need to rerun it on targets of different types. - - # NOTE: ignoring usage requirements - for t in transformed[1]: - if t.type() in missing_types: - consumed.append(t) - - else: - bypassed.append(t) - - consumed = unique(consumed) - bypassed = unique(bypassed) - - # remove elements of 'bypassed' that are in 'consumed' - - # Suppose the target type of current generator, X is produced from - # X_1 and X_2, which are produced from Y by one generator. - # When creating X_1 from Y, X_2 will be added to 'bypassed' - # Likewise, when creating X_2 from Y, X_1 will be added to 'bypassed' - # But they are also in 'consumed'. We have to remove them from - # bypassed, so that generators up the call stack don't try to convert - # them. - - # In this particular case, X_1 instance in 'consumed' and X_1 instance - # in 'bypassed' will be the same: because they have the same source and - # action name, and 'virtual-target.register' won't allow two different - # instances. Therefore, it's OK to use 'set.difference'. - - bypassed = set.difference(bypassed, consumed) - - return (consumed, bypassed) - - - def convert_multiple_sources_to_consumable_types (self, project, prop_set, sources): - """ Converts several files to consumable types. - """ - consumed = [] - bypassed = [] - - # We process each source one-by-one, trying to convert it to - # a usable type. - for s in sources: - # TODO: need to check for failure on each source. - (c, b) = self.convert_to_consumable_types (project, None, prop_set, [s], True) - if not c: - project.manager ().logger ().log (__name__, " failed to convert ", s) - - consumed.extend (c) - bypassed.extend (b) - - return (consumed, bypassed) - - def consume_directly (self, source): - real_source_type = source.type () - - # If there are no source types, we can consume anything - source_types = self.source_types() - if not source_types: - source_types = [real_source_type] - - consumed = [] - missing_types = [] - for st in source_types: - # The 'source' if of right type already) - if real_source_type == st or type.is_derived (real_source_type, st): - consumed.append (source) - - else: - missing_types.append (st) - - return (consumed, missing_types) - - def action_class (self): - """ Returns the class to be used to actions. Default implementation - returns "action". - """ - return virtual_target.Action - - -def find (id): - """ Finds the generator with id. Returns None if not found. - """ - return __generators.get (id, None) - -def register (g): - """ Registers new generator instance 'g'. - """ - id = g.id() - - __generators [id] = g - - # A generator can produce several targets of the - # same type. We want unique occurence of that generator - # in .generators.$(t) in that case, otherwise, it will - # be tried twice and we'll get false ambiguity. - for t in sequence.unique(g.target_types()): - __type_to_generators.setdefault(t, []).append(g) - - # Update the set of generators for toolset - - # TODO: should we check that generator with this id - # is not already registered. For example, the fop.jam - # module intentionally declared two generators with the - # same id, so such check will break it. - - # Some generators have multiple periods in their name, so the - # normal $(id:S=) won't generate the right toolset name. - # e.g. if id = gcc.compile.c++, then - # .generators-for-toolset.$(id:S=) will append to - # .generators-for-toolset.gcc.compile, which is a separate - # value from .generators-for-toolset.gcc. Correcting this - # makes generator inheritance work properly. - # See also inherit-generators in module toolset - base = id.split ('.', 100) [0] - - __generators_for_toolset.setdefault(base, []).append(g) - - # After adding a new generator that can construct new target types, we need - # to clear the related cached viable source target type information for - # constructing a specific target type or using a specific generator. Cached - # viable source target type lists affected by this are those containing any - # of the target types constructed by the new generator or any of their base - # target types. - # - # A more advanced alternative to clearing that cached viable source target - # type information would be to expand it with additional source types or - # even better - mark it as needing to be expanded on next use. - # - # For now we just clear all the cached viable source target type information - # that does not simply state 'all types' and may implement a more detailed - # algorithm later on if it becomes needed. - - invalidate_extendable_viable_source_target_type_cache() - - -def register_standard (id, source_types, target_types, requirements = []): - """ Creates new instance of the 'generator' class and registers it. - Returns the creates instance. - Rationale: the instance is returned so that it's possible to first register - a generator and then call 'run' method on that generator, bypassing all - generator selection. - """ - g = Generator (id, False, source_types, target_types, requirements) - register (g) - return g - -def register_composing (id, source_types, target_types, requirements = []): - g = Generator (id, True, source_types, target_types, requirements) - register (g) - return g - -def generators_for_toolset (toolset): - """ Returns all generators which belong to 'toolset'. - """ - return __generators_for_toolset.get(toolset, []) - -def override (overrider_id, overridee_id): - """Make generator 'overrider-id' be preferred to - 'overridee-id'. If, when searching for generators - that could produce a target of certain type, - both those generators are amoung viable generators, - the overridden generator is immediately discarded. - - The overridden generators are discarded immediately - after computing the list of viable generators, before - running any of them.""" - - __overrides.get(overrider_id, []).append(overridee_id) - -def __viable_source_types_real (target_type): - """ Returns a list of source type which can possibly be converted - to 'target_type' by some chain of generator invocation. - - More formally, takes all generators for 'target_type' and - returns union of source types for those generators and result - of calling itself recusrively on source types. - """ - generators = [] - - # 't0' is the initial list of target types we need to process to get a list - # of their viable source target types. New target types will not be added to - # this list. - t0 = type.all_bases (target_type) - - - # 't' is the list of target types which have not yet been processed to get a - # list of their viable source target types. This list will get expanded as - # we locate more target types to process. - t = t0 - - result = [] - while t: - # Find all generators for current type. - # Unlike 'find_viable_generators' we don't care about prop_set. - generators = __type_to_generators.get (t [0], []) - t = t[1:] - - for g in generators: - if not g.source_types(): - # Empty source types -- everything can be accepted - result = "*" - # This will terminate outer loop. - t = None - break - - for source_type in g.source_types (): - if not source_type in result: - # If generator accepts 'source_type' it - # will happily accept any type derived from it - all = type.all_derived (source_type) - for n in all: - if not n in result: - - # Here there is no point in adding target types to - # the list of types to process in case they are or - # have already been on that list. We optimize this - # check by realizing that we only need to avoid the - # original target type's base types. Other target - # types that are or have been on the list of target - # types to process have been added to the 'result' - # list as well and have thus already been eliminated - # by the previous if. - if not n in t0: - t.append (n) - result.append (n) - - return result - - -def viable_source_types (target_type): - """ Helper rule, caches the result of '__viable_source_types_real'. - """ - if not __viable_source_types_cache.has_key(target_type): - __vst_cached_types.append(target_type) - __viable_source_types_cache [target_type] = __viable_source_types_real (target_type) - return __viable_source_types_cache [target_type] - -def viable_source_types_for_generator_real (generator): - """ Returns the list of source types, which, when passed to 'run' - method of 'generator', has some change of being eventually used - (probably after conversion by other generators) - """ - source_types = generator.source_types () - - if not source_types: - # If generator does not specify any source types, - # it might be special generator like builtin.lib-generator - # which just relays to other generators. Return '*' to - # indicate that any source type is possibly OK, since we don't - # know for sure. - return ['*'] - - else: - result = [] - for s in source_types: - viable_sources = viable_source_types(s) - if viable_sources == "*": - result = ["*"] - break - else: - result.extend(type.all_derived(s) + viable_sources) - return unique(result) - -def viable_source_types_for_generator (generator): - """ Caches the result of 'viable_source_types_for_generator'. - """ - if not __viable_source_types_cache.has_key(generator): - __vstg_cached_generators.append(generator) - __viable_source_types_cache[generator] = viable_source_types_for_generator_real (generator) - - return __viable_source_types_cache[generator] - -def try_one_generator_really (project, name, generator, target_type, properties, sources): - """ Returns usage requirements + list of created targets. - """ - targets = generator.run (project, name, properties, sources) - - usage_requirements = [] - success = False - - dout("returned " + str(targets)) - - if targets: - success = True; - - if isinstance (targets[0], property_set.PropertySet): - usage_requirements = targets [0] - targets = targets [1] - - else: - usage_requirements = property_set.empty () - - dout( " generator" + generator.id() + " spawned ") - # generators.dout [ indent ] " " $(targets) ; -# if $(usage-requirements) -# { -# generators.dout [ indent ] " with usage requirements:" $(x) ; -# } - - if success: - return (usage_requirements, targets) - else: - return None - -def try_one_generator (project, name, generator, target_type, properties, sources): - """ Checks if generator invocation can be pruned, because it's guaranteed - to fail. If so, quickly returns empty list. Otherwise, calls - try_one_generator_really. - """ - source_types = [] - - for s in sources: - source_types.append (s.type ()) - - viable_source_types = viable_source_types_for_generator (generator) - - if source_types and viable_source_types != ['*'] and\ - not set.intersection (source_types, viable_source_types): - if project.manager ().logger ().on (): - id = generator.id () - project.manager ().logger ().log (__name__, "generator '%s' pruned" % id) - project.manager ().logger ().log (__name__, "source_types" '%s' % source_types) - project.manager ().logger ().log (__name__, "viable_source_types '%s'" % viable_source_types) - - return [] - - else: - return try_one_generator_really (project, name, generator, target_type, properties, sources) - - -def construct_types (project, name, target_types, prop_set, sources): - - result = [] - usage_requirements = property_set.empty() - - for t in target_types: - r = construct (project, name, t, prop_set, sources) - - if r: - (ur, targets) = r - usage_requirements = usage_requirements.add(ur) - result.extend(targets) - - # TODO: have to introduce parameter controlling if - # several types can be matched and add appropriate - # checks - - # TODO: need to review the documentation for - # 'construct' to see if it should return $(source) even - # if nothing can be done with it. Currents docs seem to - # imply that, contrary to the behaviour. - if result: - return (usage_requirements, result) - - else: - return (usage_requirements, sources) - -def __ensure_type (targets): - """ Ensures all 'targets' have types. If this is not so, exists with - error. - """ - for t in targets: - if not t.type (): - get_manager().errors()("target '%s' has no type" % str (t)) - -def find_viable_generators_aux (target_type, prop_set): - """ Returns generators which can be used to construct target of specified type - with specified properties. Uses the following algorithm: - - iterates over requested target_type and all it's bases (in the order returned bt - type.all-bases. - - for each type find all generators that generate that type and which requirements - are satisfied by properties. - - if the set of generators is not empty, returns that set. - - Note: this algorithm explicitly ignores generators for base classes if there's - at least one generator for requested target_type. - """ - # Select generators that can create the required target type. - viable_generators = [] - initial_generators = [] - - import type - - # Try all-type generators first. Assume they have - # quite specific requirements. - all_bases = type.all_bases(target_type) - - for t in all_bases: - - initial_generators = __type_to_generators.get(t, []) - - if initial_generators: - dout("there are generators for this type") - if t != target_type: - # We're here, when no generators for target-type are found, - # but there are some generators for a base type. - # We'll try to use them, but they will produce targets of - # base type, not of 'target-type'. So, we clone the generators - # and modify the list of target types. - generators2 = [] - for g in initial_generators[:]: - # generators.register adds generator to the list of generators - # for toolsets, which is a bit strange, but should work. - # That list is only used when inheriting toolset, which - # should have being done before generators are run. - ng = g.clone_and_change_target_type(t, target_type) - generators2.append(ng) - register(ng) - - initial_generators = generators2 - break - - for g in initial_generators: - dout("trying generator " + g.id() - + "(" + str(g.source_types()) + "->" + str(g.target_types()) + ")") - - m = g.match_rank(prop_set) - if m: - dout(" is viable") - viable_generators.append(g) - - return viable_generators - -def find_viable_generators (target_type, prop_set): - key = target_type + '.' + str (prop_set) - - l = __viable_generators_cache.get (key, None) - if not l: - l = [] - - if not l: - l = find_viable_generators_aux (target_type, prop_set) - - __viable_generators_cache [key] = l - - viable_generators = [] - for g in l: - # Avoid trying the same generator twice on different levels. - # TODO: is this really used? - if not g in __active_generators: - viable_generators.append (g) - else: - dout(" generator %s is active, discarding" % g.id()) - - # Generators which override 'all'. - all_overrides = [] - - # Generators which are overriden - overriden_ids = [] - - for g in viable_generators: - id = g.id () - - this_overrides = __overrides.get (id, []) - - if this_overrides: - overriden_ids.extend (this_overrides) - if 'all' in this_overrides: - all_overrides.append (g) - - if all_overrides: - viable_generators = all_overrides - - result = [] - for g in viable_generators: - if not g.id () in overriden_ids: - result.append (g) - - - return result - -def __construct_really (project, name, target_type, prop_set, sources): - """ Attempts to construct target by finding viable generators, running them - and selecting the dependency graph. - """ - viable_generators = find_viable_generators (target_type, prop_set) - - result = [] - - project.manager ().logger ().log (__name__, "*** %d viable generators" % len (viable_generators)) - - generators_that_succeeded = [] - - for g in viable_generators: - __active_generators.append(g) - r = try_one_generator (project, name, g, target_type, prop_set, sources) - del __active_generators[-1] - - if r: - generators_that_succeeded.append(g) - if result: - output = cStringIO.StringIO() - print >>output, "ambiguity found when searching for best transformation" - print >>output, "Trying to produce type '%s' from: " % (target_type) - for s in sources: - print >>output, " - " + s.str() - print >>output, "Generators that succeeded:" - for g in generators_that_succeeded: - print >>output, " - " + g.id() - print >>output, "First generator produced: " - for t in result[1:]: - print >>output, " - " + str(t) - print >>output, "Second generator produced:" - for t in r[1:]: - print >>output, " - " + str(t) - get_manager().errors()(output.getvalue()) - else: - result = r; - - return result; - - -def construct (project, name, target_type, prop_set, sources, top_level=False): - """ Attempts to create target of 'target-type' with 'properties' - from 'sources'. The 'sources' are treated as a collection of - *possible* ingridients -- i.e. it is not required to consume - them all. If 'multiple' is true, the rule is allowed to return - several targets of 'target-type'. - - Returns a list of target. When this invocation is first instance of - 'construct' in stack, returns only targets of requested 'target-type', - otherwise, returns also unused sources and additionally generated - targets. - - If 'top-level' is set, does not suppress generators that are already - used in the stack. This may be useful in cases where a generator - has to build a metatarget -- for example a target corresponding to - built tool. - """ - - global __active_generators - if top_level: - saved_active = __active_generators - __active_generators = [] - - global __construct_stack - if not __construct_stack: - __ensure_type (sources) - - __construct_stack.append (1) - - if project.manager().logger().on(): - increase_indent () - - dout( "*** construct " + target_type) - - for s in sources: - dout(" from " + str(s)) - - project.manager().logger().log (__name__, " properties: ", prop_set.raw ()) - - result = __construct_really(project, name, target_type, prop_set, sources) - - project.manager().logger().decrease_indent() - - __construct_stack = __construct_stack [1:] - - if top_level: - __active_generators = saved_active - - return result - diff --git a/jam-files/boost-build/build/modifiers.jam b/jam-files/boost-build/build/modifiers.jam deleted file mode 100644 index 6b009343..00000000 --- a/jam-files/boost-build/build/modifiers.jam +++ /dev/null @@ -1,232 +0,0 @@ -# Copyright 2003 Rene Rivera -# 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) - -# Modifiers are generalized generators that mutate targets in specific ways. -# This structure allows for grouping a variety of functionality in an -# orthogonal way to the functionality in toolsets, and without specifying -# more target variations. In turn the modifiers can be used as building -# blocks to implement simple requests, like the <version> feature. - -import modules ; -import feature ; -import errors ; -import type ; -import "class" : new ; -import generators ; -import property ; -import virtual-target ; -import numbers ; -import sequence ; -import symlink ; -import property-set ; - -# Base generator for creating targets that are modifications of existing -# targets. -# -class modifier : generator -{ - rule __init__ ( - id - composing ? - : source-types * - : target-types-and-names + - : requirements * - ) - { - generator.__init__ $(id) $(composing) - : $(source-types) - : $(target-types-and-names) - : $(requirements) ; - - self.targets-in-progress = ; - } - - # Wraps the generation of the target to call before and after rules to - # affect the real target. - # - rule run ( project name ? : property-set : sources + ) - { - local result ; - local current-target = $(project)^$(name) ; - if ! $(current-target) in $(self.targets-in-progress) - { - # Before modifications... - local project_ = - [ modify-project-before - $(project) $(name) : $(property-set) : $(sources) ] ; - local name_ = - [ modify-name-before - $(project) $(name) : $(property-set) : $(sources) ] ; - local property-set_ = - [ modify-properties-before - $(project) $(name) : $(property-set) : $(sources) ] ; - local sources_ = - [ modify-sources-before - $(project) $(name) : $(property-set) : $(sources) ] ; - project = $(project_) ; - name = $(name_) ; - property-set = $(property-set_) ; - sources = $(sources_) ; - - # Generate the real target... - local target-type-p = - [ property.select <main-target-type> : [ $(property-set).raw ] ] ; - self.targets-in-progress += $(current-target) ; - result = - [ generators.construct $(project) $(name) - : $(target-type-p:G=) - : $(property-set) - : $(sources) ] ; - self.targets-in-progress = $(self.targets-in-progress[1--2]) ; - - # After modifications... - result = - [ modify-target-after $(result) - : $(project) $(name) - : $(property-set) - : $(sources) ] ; - } - return $(result) ; - } - - rule modify-project-before ( project name ? : property-set : sources + ) - { - return $(project) ; - } - - rule modify-name-before ( project name ? : property-set : sources + ) - { - return $(name) ; - } - - rule modify-properties-before ( project name ? : property-set : sources + ) - { - return $(property-set) ; - } - - rule modify-sources-before ( project name ? : property-set : sources + ) - { - return $(sources) ; - } - - rule modify-target-after ( target : project name ? : property-set : sources + ) - { - return $(target) ; - } - - # Utility, clones a file-target with optional changes to the name, type and - # project of the target. - # NOTE: This functionality should be moved, and generalized, to - # virtual-targets. - # - rule clone-file-target ( target : new-name ? : new-type ? : new-project ? ) - { - # Need a MUTCH better way to clone a target... - new-name ?= [ $(target).name ] ; - new-type ?= [ $(target).type ] ; - new-project ?= [ $(target).project ] ; - local result = [ new file-target $(new-name) : $(new-type) : $(new-project) ] ; - - if [ $(target).dependencies ] { $(result).depends [ $(target).dependencies ] ; } - $(result).root [ $(target).root ] ; - $(result).set-usage-requirements [ $(target).usage-requirements ] ; - - local action = [ $(target).action ] ; - local action-class = [ modules.peek $(action) : __class__ ] ; - - local ps = [ $(action).properties ] ; - local cloned-action = [ new $(action-class) $(result) : - [ $(action).sources ] : [ $(action).action-name ] : $(ps) ] ; - $(result).action $(cloned-action) ; - - return $(result) ; - } -} - - -# A modifier that changes the name of a target, after it's generated, given a -# regular expression to split the name, and a set of token to insert between the -# split tokens of the name. This also exposes the target for other uses with a -# symlink to the original name (optionally). -# -class name-modifier : modifier -{ - rule __init__ ( ) - { - # Apply ourselves to EXE targets, for now. - modifier.__init__ name.modifier : : EXE LIB : <name-modify>yes ; - } - - # Modifies the name, by cloning the target with the new name. - # - rule modify-target-after ( target : project name ? : property-set : sources + ) - { - local result = $(target) ; - - local name-mod-p = [ property.select <name-modifier> : [ $(property-set).raw ] ] ; - if $(name-mod-p) - { - local new-name = [ modify-name [ $(target).name ] : $(name-mod-p:G=) ] ; - if $(new-name) != [ $(target).name ] - { - result = [ clone-file-target $(target) : $(new-name) ] ; - } - local expose-original-as-symlink = [ MATCH "<symlink>(.*)" : $(name-mod-p) ] ; - if $(expose-original-as-symlink) - { - local symlink-t = [ new symlink-targets $(project) : $(name) : [ $(result).name ] ] ; - result = [ $(symlink-t).construct $(result) - : [ property-set.create [ $(property-set).raw ] <symlink-location>build-relative ] ] ; - } - } - - return $(result) ; - } - - # Do the transformation of the name. - # - rule modify-name ( name : modifier-spec + ) - { - local match = [ MATCH "<match>(.*)" : $(modifier-spec) ] ; - local name-parts = [ MATCH $(match) : $(name) ] ; - local insertions = [ sequence.insertion-sort [ MATCH "(<[0123456789]+>.*)" : $(modifier-spec) ] ] ; - local new-name-parts ; - local insert-position = 1 ; - while $(insertions) - { - local insertion = [ MATCH "<$(insert-position)>(.*)" : $(insertions[1]) ] ; - if $(insertion) - { - new-name-parts += $(insertion) ; - insertions = $(insertions[2-]) ; - } - new-name-parts += $(name-parts[1]) ; - name-parts = $(name-parts[2-]) ; - insert-position = [ numbers.increment $(insert-position) ] ; - } - new-name-parts += $(name-parts) ; - return [ sequence.join $(new-name-parts) ] ; - } - - rule optional-properties ( ) - { - return <name-modify>yes ; - } -} -feature.feature name-modifier : : free ; -feature.feature name-modify : no yes : incidental optional ; -generators.register [ new name-modifier ] ; - -# Translates <version> property to a set of modification properties -# that are applied by the name-modifier, and symlink-modifier. -# -rule version-to-modifier ( property : properties * ) -{ - return - <name-modify>yes - <name-modifier><match>"^([^.]*)(.*)" <name-modifier><2>.$(property:G=) - <name-modifier><symlink>yes - ; -} -feature.action <version> : version-to-modifier ; diff --git a/jam-files/boost-build/build/project.ann.py b/jam-files/boost-build/build/project.ann.py deleted file mode 100644 index 349f5495..00000000 --- a/jam-files/boost-build/build/project.ann.py +++ /dev/null @@ -1,996 +0,0 @@ -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 1) # Status: being ported by Vladimir Prus -ddc17f01 (vladimir_prus 2007-10-26 14:57:56 +0000 2) # Base revision: 40480 -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 3) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 4) # Copyright 2002, 2003 Dave Abrahams -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 5) # Copyright 2002, 2005, 2006 Rene Rivera -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 6) # Copyright 2002, 2003, 2004, 2005, 2006 Vladimir Prus -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 7) # Distributed under the Boost Software License, Version 1.0. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 8) # (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 9) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 10) # Implements project representation and loading. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 11) # Each project is represented by -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 12) # - a module where all the Jamfile content live. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 13) # - an instance of 'project-attributes' class. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 14) # (given module name, can be obtained by 'attributes' rule) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 15) # - an instance of 'project-target' class (from targets.jam) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 16) # (given a module name, can be obtained by 'target' rule) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 17) # -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 18) # Typically, projects are created as result of loading Jamfile, which is -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 19) # do by rules 'load' and 'initialize', below. First, module for Jamfile -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 20) # is loaded and new project-attributes instance is created. Some rules -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 21) # necessary for project are added to the module (see 'project-rules' module) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 22) # at the bottom of this file. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 23) # Default project attributes are set (inheriting attributes of parent project, if -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 24) # it exists). After that, Jamfile is read. It can declare its own attributes, -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 25) # via 'project' rule, which will be combined with already set attributes. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 26) # -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 27) # -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 28) # The 'project' rule can also declare project id, which will be associated with -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 29) # the project module. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 30) # -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 31) # There can also be 'standalone' projects. They are created by calling 'initialize' -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 32) # on arbitrary module, and not specifying location. After the call, the module can -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 33) # call 'project' rule, declare main target and behave as regular projects. However, -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 34) # since it's not associated with any location, it's better declare only prebuilt -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 35) # targets. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 36) # -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 37) # The list of all loaded Jamfile is stored in variable .project-locations. It's possible -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 38) # to obtain module name for a location using 'module-name' rule. The standalone projects -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 39) # are not recorded, the only way to use them is by project id. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 40) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 41) import b2.util.path -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 42) from b2.build import property_set, property -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 43) from b2.build.errors import ExceptionWithUserContext -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 44) import b2.build.targets -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 45) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 46) import bjam -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 47) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 48) import re -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 49) import sys -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 50) import os -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 51) import string -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 52) import imp -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 53) import traceback -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 54) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 55) class ProjectRegistry: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 56) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 57) def __init__(self, manager, global_build_dir): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 58) self.manager = manager -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 59) self.global_build_dir = None -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 60) self.project_rules_ = ProjectRules(self) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 61) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 62) # The target corresponding to the project being loaded now -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 63) self.current_project = None -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 64) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 65) # The set of names of loaded project modules -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 66) self.jamfile_modules = {} -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 67) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 68) # Mapping from location to module name -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 69) self.location2module = {} -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 70) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 71) # Mapping from project id to project module -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 72) self.id2module = {} -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 73) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 74) # Map from Jamfile directory to parent Jamfile/Jamroot -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 75) # location. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 76) self.dir2parent_jamfile = {} -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 77) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 78) # Map from directory to the name of Jamfile in -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 79) # that directory (or None). -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 80) self.dir2jamfile = {} -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 81) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 82) # Map from project module to attributes object. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 83) self.module2attributes = {} -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 84) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 85) # Map from project module to target for the project -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 86) self.module2target = {} -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 87) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 88) # Map from names to Python modules, for modules loaded -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 89) # via 'using' and 'import' rules in Jamfiles. -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 90) self.loaded_tool_modules_ = {} -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 91) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 92) # Map from project target to the list of -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 93) # (id,location) pairs corresponding to all 'use-project' -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 94) # invocations. -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 95) # TODO: should not have a global map, keep this -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 96) # in ProjectTarget. -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 97) self.used_projects = {} -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 98) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 99) self.saved_current_project = [] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 100) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 101) self.JAMROOT = self.manager.getenv("JAMROOT"); -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 102) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 103) # Note the use of character groups, as opposed to listing -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 104) # 'Jamroot' and 'jamroot'. With the latter, we'd get duplicate -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 105) # matches on windows and would have to eliminate duplicates. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 106) if not self.JAMROOT: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 107) self.JAMROOT = ["project-root.jam", "[Jj]amroot", "[Jj]amroot.jam"] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 108) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 109) # Default patterns to search for the Jamfiles to use for build -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 110) # declarations. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 111) self.JAMFILE = self.manager.getenv("JAMFILE") -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 112) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 113) if not self.JAMFILE: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 114) self.JAMFILE = ["[Bb]uild.jam", "[Jj]amfile.v2", "[Jj]amfile", -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 115) "[Jj]amfile.jam"] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 116) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 117) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 118) def load (self, jamfile_location): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 119) """Loads jamfile at the given location. After loading, project global -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 120) file and jamfile needed by the loaded one will be loaded recursively. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 121) If the jamfile at that location is loaded already, does nothing. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 122) Returns the project module for the Jamfile.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 123) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 124) absolute = os.path.join(os.getcwd(), jamfile_location) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 125) absolute = os.path.normpath(absolute) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 126) jamfile_location = b2.util.path.relpath(os.getcwd(), absolute) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 127) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 128) if "--debug-loading" in self.manager.argv(): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 129) print "Loading Jamfile at '%s'" % jamfile_location -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 130) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 131) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 132) mname = self.module_name(jamfile_location) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 133) # If Jamfile is already loaded, don't try again. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 134) if not mname in self.jamfile_modules: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 135) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 136) self.load_jamfile(jamfile_location) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 137) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 138) # We want to make sure that child project are loaded only -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 139) # after parent projects. In particular, because parent projects -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 140) # define attributes whch are inherited by children, and we don't -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 141) # want children to be loaded before parents has defined everything. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 142) # -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 143) # While "build-project" and "use-project" can potentially refer -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 144) # to child projects from parent projects, we don't immediately -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 145) # load child projects when seing those attributes. Instead, -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 146) # we record the minimal information that will be used only later. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 147) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 148) self.load_used_projects(mname) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 149) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 150) return mname -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 151) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 152) def load_used_projects(self, module_name): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 153) # local used = [ modules.peek $(module-name) : .used-projects ] ; -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 154) used = self.used_projects[module_name] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 155) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 156) location = self.attribute(module_name, "location") -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 157) for u in used: -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 158) id = u[0] -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 159) where = u[1] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 160) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 161) self.use(id, os.path.join(location, where)) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 162) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 163) def load_parent(self, location): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 164) """Loads parent of Jamfile at 'location'. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 165) Issues an error if nothing is found.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 166) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 167) found = b2.util.path.glob_in_parents( -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 168) location, self.JAMROOT + self.JAMFILE) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 169) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 170) if not found: -1674e2d9 (jhunold 2008-08-08 19:52:05 +0000 171) print "error: Could not find parent for project at '%s'" % location -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 172) print "error: Did not find Jamfile or project-root.jam in any parent directory." -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 173) sys.exit(1) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 174) -49c03622 (jhunold 2008-07-23 09:57:41 +0000 175) return self.load(os.path.dirname(found[0])) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 176) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 177) def act_as_jamfile(self, module, location): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 178) """Makes the specified 'module' act as if it were a regularly loaded Jamfile -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 179) at 'location'. If Jamfile is already located for that location, it's an -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 180) error.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 181) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 182) if self.module_name(location) in self.jamfile_modules: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 183) self.manager.errors()( -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 184) "Jamfile was already loaded for '%s'" % location) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 185) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 186) # Set up non-default mapping from location to module. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 187) self.location2module[location] = module -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 188) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 189) # Add the location to the list of project locations -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 190) # so that we don't try to load Jamfile in future -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 191) self.jamfile_modules.append(location) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 192) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 193) self.initialize(module, location) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 194) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 195) def find(self, name, current_location): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 196) """Given 'name' which can be project-id or plain directory name, -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 197) return project module corresponding to that id or directory. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 198) Returns nothing of project is not found.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 199) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 200) project_module = None -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 201) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 202) # Try interpreting name as project id. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 203) if name[0] == '/': -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 204) project_module = self.id2module.get(name) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 205) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 206) if not project_module: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 207) location = os.path.join(current_location, name) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 208) # If no project is registered for the given location, try to -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 209) # load it. First see if we have Jamfile. If not we might have project -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 210) # root, willing to act as Jamfile. In that case, project-root -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 211) # must be placed in the directory referred by id. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 212) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 213) project_module = self.module_name(location) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 214) if not project_module in self.jamfile_modules and \ -49c03622 (jhunold 2008-07-23 09:57:41 +0000 215) b2.util.path.glob([location], self.JAMROOT + self.JAMFILE): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 216) project_module = self.load(location) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 217) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 218) return project_module -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 219) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 220) def module_name(self, jamfile_location): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 221) """Returns the name of module corresponding to 'jamfile-location'. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 222) If no module corresponds to location yet, associates default -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 223) module name with that location.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 224) module = self.location2module.get(jamfile_location) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 225) if not module: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 226) # Root the path, so that locations are always umbiguious. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 227) # Without this, we can't decide if '../../exe/program1' and '.' -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 228) # are the same paths, or not. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 229) jamfile_location = os.path.realpath( -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 230) os.path.join(os.getcwd(), jamfile_location)) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 231) module = "Jamfile<%s>" % jamfile_location -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 232) self.location2module[jamfile_location] = module -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 233) return module -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 234) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 235) def find_jamfile (self, dir, parent_root=0, no_errors=0): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 236) """Find the Jamfile at the given location. This returns the -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 237) exact names of all the Jamfiles in the given directory. The optional -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 238) parent-root argument causes this to search not the given directory -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 239) but the ones above it up to the directory given in it.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 240) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 241) # Glob for all the possible Jamfiles according to the match pattern. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 242) # -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 243) jamfile_glob = None -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 244) if parent_root: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 245) parent = self.dir2parent_jamfile.get(dir) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 246) if not parent: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 247) parent = b2.util.path.glob_in_parents(dir, -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 248) self.JAMFILE) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 249) self.dir2parent_jamfile[dir] = parent -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 250) jamfile_glob = parent -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 251) else: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 252) jamfile = self.dir2jamfile.get(dir) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 253) if not jamfile: -49c03622 (jhunold 2008-07-23 09:57:41 +0000 254) jamfile = b2.util.path.glob([dir], self.JAMFILE) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 255) self.dir2jamfile[dir] = jamfile -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 256) jamfile_glob = jamfile -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 257) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 258) if len(jamfile_glob): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 259) # Multiple Jamfiles found in the same place. Warn about this. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 260) # And ensure we use only one of them. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 261) # As a temporary convenience measure, if there's Jamfile.v2 amount -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 262) # found files, suppress the warning and use it. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 263) # -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 264) pattern = "(.*[Jj]amfile\\.v2)|(.*[Bb]uild\\.jam)" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 265) v2_jamfiles = [x for x in jamfile_glob if re.match(pattern, x)] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 266) if len(v2_jamfiles) == 1: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 267) jamfile_glob = v2_jamfiles -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 268) else: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 269) print """warning: Found multiple Jamfiles at '%s'! -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 270) Loading the first one: '%s'.""" % (dir, jamfile_glob[0]) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 271) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 272) # Could not find it, error. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 273) if not no_errors and not jamfile_glob: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 274) self.manager.errors()( -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 275) """Unable to load Jamfile. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 276) Could not find a Jamfile in directory '%s' -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 277) Attempted to find it with pattern '%s'. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 278) Please consult the documentation at 'http://boost.org/b2.'.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 279) % (dir, string.join(self.JAMFILE))) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 280) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 281) return jamfile_glob[0] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 282) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 283) def load_jamfile(self, dir): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 284) """Load a Jamfile at the given directory. Returns nothing. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 285) Will attempt to load the file as indicated by the JAMFILE patterns. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 286) Effect of calling this rule twice with the same 'dir' is underfined.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 287) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 288) # See if the Jamfile is where it should be. -49c03622 (jhunold 2008-07-23 09:57:41 +0000 289) jamfile_to_load = b2.util.path.glob([dir], self.JAMROOT) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 290) if not jamfile_to_load: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 291) jamfile_to_load = self.find_jamfile(dir) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 292) else: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 293) jamfile_to_load = jamfile_to_load[0] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 294) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 295) # The module of the jamfile. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 296) dir = os.path.realpath(os.path.dirname(jamfile_to_load)) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 297) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 298) jamfile_module = self.module_name (dir) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 299) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 300) # Initialize the jamfile module before loading. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 301) # -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 302) self.initialize(jamfile_module, dir, os.path.basename(jamfile_to_load)) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 303) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 304) saved_project = self.current_project -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 305) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 306) self.used_projects[jamfile_module] = [] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 307) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 308) # Now load the Jamfile in it's own context. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 309) # Initialization might have load parent Jamfiles, which might have -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 310) # loaded the current Jamfile with use-project. Do a final check to make -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 311) # sure it's not loaded already. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 312) if not jamfile_module in self.jamfile_modules: -49c03622 (jhunold 2008-07-23 09:57:41 +0000 313) self.jamfile_modules[jamfile_module] = True -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 314) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 315) # FIXME: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 316) # mark-as-user $(jamfile-module) ; -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 317) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 318) bjam.call("load", jamfile_module, jamfile_to_load) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 319) basename = os.path.basename(jamfile_to_load) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 320) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 321) # Now do some checks -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 322) if self.current_project != saved_project: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 323) self.manager.errors()( -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 324) """The value of the .current-project variable -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 325) has magically changed after loading a Jamfile. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 326) This means some of the targets might be defined a the wrong project. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 327) after loading %s -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 328) expected value %s -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 329) actual value %s""" % (jamfile_module, saved_project, self.current_project)) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 330) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 331) if self.global_build_dir: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 332) id = self.attribute(jamfile_module, "id") -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 333) project_root = self.attribute(jamfile_module, "project-root") -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 334) location = self.attribute(jamfile_module, "location") -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 335) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 336) if location and project_root == dir: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 337) # This is Jamroot -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 338) if not id: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 339) # FIXME: go via errors module, so that contexts are -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 340) # shown? -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 341) print "warning: the --build-dir option was specified" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 342) print "warning: but Jamroot at '%s'" % dir -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 343) print "warning: specified no project id" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 344) print "warning: the --build-dir option will be ignored" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 345) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 346) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 347) def load_standalone(self, jamfile_module, file): -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 348) """Loads 'file' as standalone project that has no location -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 349) associated with it. This is mostly useful for user-config.jam, -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 350) which should be able to define targets, but although it has -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 351) some location in filesystem, we don't want any build to -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 352) happen in user's HOME, for example. -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 353) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 354) The caller is required to never call this method twice on -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 355) the same file. -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 356) """ -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 357) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 358) self.initialize(jamfile_module) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 359) self.used_projects[jamfile_module] = [] -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 360) bjam.call("load", jamfile_module, file) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 361) self.load_used_projects(jamfile_module) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 362) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 363) def is_jamroot(self, basename): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 364) match = [ pat for pat in self.JAMROOT if re.match(pat, basename)] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 365) if match: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 366) return 1 -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 367) else: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 368) return 0 -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 369) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 370) def initialize(self, module_name, location=None, basename=None): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 371) """Initialize the module for a project. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 372) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 373) module-name is the name of the project module. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 374) location is the location (directory) of the project to initialize. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 375) If not specified, stanalone project will be initialized -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 376) """ -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 377) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 378) if "--debug-loading" in self.manager.argv(): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 379) print "Initializing project '%s'" % module_name -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 380) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 381) # TODO: need to consider if standalone projects can do anything but defining -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 382) # prebuilt targets. If so, we need to give more sensible "location", so that -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 383) # source paths are correct. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 384) if not location: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 385) location = "" -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 386) else: -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 387) location = b2.util.path.relpath(os.getcwd(), location) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 388) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 389) attributes = ProjectAttributes(self.manager, location, module_name) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 390) self.module2attributes[module_name] = attributes -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 391) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 392) if location: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 393) attributes.set("source-location", location, exact=1) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 394) else: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 395) attributes.set("source-location", "", exact=1) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 396) -49c03622 (jhunold 2008-07-23 09:57:41 +0000 397) attributes.set("requirements", property_set.empty(), exact=True) -49c03622 (jhunold 2008-07-23 09:57:41 +0000 398) attributes.set("usage-requirements", property_set.empty(), exact=True) -49c03622 (jhunold 2008-07-23 09:57:41 +0000 399) attributes.set("default-build", [], exact=True) -49c03622 (jhunold 2008-07-23 09:57:41 +0000 400) attributes.set("projects-to-build", [], exact=True) -49c03622 (jhunold 2008-07-23 09:57:41 +0000 401) attributes.set("project-root", None, exact=True) -49c03622 (jhunold 2008-07-23 09:57:41 +0000 402) attributes.set("build-dir", None, exact=True) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 403) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 404) self.project_rules_.init_project(module_name) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 405) -49c03622 (jhunold 2008-07-23 09:57:41 +0000 406) jamroot = False -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 407) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 408) parent_module = None; -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 409) if module_name == "site-config": -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 410) # No parent -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 411) pass -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 412) elif module_name == "user-config": -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 413) parent_module = "site-config" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 414) elif location and not self.is_jamroot(basename): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 415) # We search for parent/project-root only if jamfile was specified -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 416) # --- i.e -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 417) # if the project is not standalone. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 418) parent_module = self.load_parent(location) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 419) else: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 420) # It's either jamroot, or standalone project. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 421) # If it's jamroot, inherit from user-config. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 422) if location: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 423) parent_module = "user-config" ; -49c03622 (jhunold 2008-07-23 09:57:41 +0000 424) jamroot = True ; -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 425) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 426) if parent_module: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 427) self.inherit_attributes(module_name, parent_module) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 428) attributes.set("parent-module", parent_module, exact=1) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 429) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 430) if jamroot: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 431) attributes.set("project-root", location, exact=1) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 432) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 433) parent = None -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 434) if parent_module: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 435) parent = self.target(parent_module) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 436) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 437) if not self.module2target.has_key(module_name): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 438) target = b2.build.targets.ProjectTarget(self.manager, -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 439) module_name, module_name, parent, -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 440) self.attribute(module_name,"requirements"), -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 441) # FIXME: why we need to pass this? It's not -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 442) # passed in jam code. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 443) self.attribute(module_name, "default-build")) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 444) self.module2target[module_name] = target -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 445) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 446) self.current_project = self.target(module_name) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 447) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 448) def inherit_attributes(self, project_module, parent_module): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 449) """Make 'project-module' inherit attributes of project -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 450) root and parent module.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 451) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 452) attributes = self.module2attributes[project_module] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 453) pattributes = self.module2attributes[parent_module] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 454) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 455) # Parent module might be locationless user-config. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 456) # FIXME: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 457) #if [ modules.binding $(parent-module) ] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 458) #{ -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 459) # $(attributes).set parent : [ path.parent -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 460) # [ path.make [ modules.binding $(parent-module) ] ] ] ; -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 461) # } -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 462) -49c03622 (jhunold 2008-07-23 09:57:41 +0000 463) attributes.set("project-root", pattributes.get("project-root"), exact=True) -49c03622 (jhunold 2008-07-23 09:57:41 +0000 464) attributes.set("default-build", pattributes.get("default-build"), exact=True) -49c03622 (jhunold 2008-07-23 09:57:41 +0000 465) attributes.set("requirements", pattributes.get("requirements"), exact=True) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 466) attributes.set("usage-requirements", -cde6f09a (vladimir_prus 2007-10-19 23:12:33 +0000 467) pattributes.get("usage-requirements"), exact=1) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 468) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 469) parent_build_dir = pattributes.get("build-dir") -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 470) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 471) if parent_build_dir: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 472) # Have to compute relative path from parent dir to our dir -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 473) # Convert both paths to absolute, since we cannot -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 474) # find relative path from ".." to "." -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 475) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 476) location = attributes.get("location") -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 477) parent_location = pattributes.get("location") -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 478) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 479) our_dir = os.path.join(os.getcwd(), location) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 480) parent_dir = os.path.join(os.getcwd(), parent_location) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 481) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 482) build_dir = os.path.join(parent_build_dir, -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 483) b2.util.path.relpath(parent_dir, -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 484) our_dir)) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 485) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 486) def register_id(self, id, module): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 487) """Associate the given id with the given project module.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 488) self.id2module[id] = module -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 489) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 490) def current(self): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 491) """Returns the project which is currently being loaded.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 492) return self.current_project -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 493) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 494) def push_current(self, project): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 495) """Temporary changes the current project to 'project'. Should -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 496) be followed by 'pop-current'.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 497) self.saved_current_project.append(self.current_project) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 498) self.current_project = project -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 499) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 500) def pop_current(self): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 501) self.current_project = self.saved_current_project[-1] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 502) del self.saved_current_project[-1] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 503) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 504) def attributes(self, project): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 505) """Returns the project-attribute instance for the -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 506) specified jamfile module.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 507) return self.module2attributes[project] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 508) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 509) def attribute(self, project, attribute): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 510) """Returns the value of the specified attribute in the -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 511) specified jamfile module.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 512) return self.module2attributes[project].get(attribute) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 513) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 514) def target(self, project_module): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 515) """Returns the project target corresponding to the 'project-module'.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 516) if not self.module2target[project_module]: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 517) self.module2target[project_module] = \ -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 518) ProjectTarget(project_module, project_module, -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 519) self.attribute(project_module, "requirements")) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 520) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 521) return self.module2target[project_module] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 522) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 523) def use(self, id, location): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 524) # Use/load a project. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 525) saved_project = self.current_project -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 526) project_module = self.load(location) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 527) declared_id = self.attribute(project_module, "id") -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 528) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 529) if not declared_id or declared_id != id: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 530) # The project at 'location' either have no id or -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 531) # that id is not equal to the 'id' parameter. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 532) if self.id2module[id] and self.id2module[id] != project_module: -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 533) self.manager.errors()( -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 534) """Attempt to redeclare already existing project id '%s'""" % id) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 535) self.id2module[id] = project_module -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 536) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 537) self.current_module = saved_project -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 538) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 539) def add_rule(self, name, callable): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 540) """Makes rule 'name' available to all subsequently loaded Jamfiles. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 541) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 542) Calling that rule wil relay to 'callable'.""" -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 543) self.project_rules_.add_rule(name, callable) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 544) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 545) def project_rules(self): -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 546) return self.project_rules_ -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 547) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 548) def glob_internal(self, project, wildcards, excludes, rule_name): -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 549) location = project.get("source-location") -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 550) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 551) result = [] -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 552) callable = b2.util.path.__dict__[rule_name] -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 553) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 554) paths = callable(location, wildcards, excludes) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 555) has_dir = 0 -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 556) for w in wildcards: -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 557) if os.path.dirname(w): -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 558) has_dir = 1 -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 559) break -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 560) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 561) if has_dir or rule_name != "glob": -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 562) # The paths we've found are relative to current directory, -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 563) # but the names specified in sources list are assumed to -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 564) # be relative to source directory of the corresponding -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 565) # prject. So, just make the name absolute. -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 566) result = [os.path.join(os.getcwd(), p) for p in paths] -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 567) else: -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 568) # There were not directory in wildcard, so the files are all -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 569) # in the source directory of the project. Just drop the -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 570) # directory, instead of making paths absolute. -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 571) result = [os.path.basename(p) for p in paths] -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 572) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 573) return result -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 574) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 575) def load_module(self, name, extra_path=None): -53b0faa2 (jhunold 2008-08-10 18:25:50 +0000 576) """Classic Boost.Build 'modules' are in fact global variables. -53b0faa2 (jhunold 2008-08-10 18:25:50 +0000 577) Therefore, try to find an already loaded Python module called 'name' in sys.modules. -53b0faa2 (jhunold 2008-08-10 18:25:50 +0000 578) If the module ist not loaded, find it Boost.Build search -53b0faa2 (jhunold 2008-08-10 18:25:50 +0000 579) path and load it. The new module is not entered in sys.modules. -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 580) The motivation here is to have disjoint namespace of modules -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 581) loaded via 'import/using' in Jamfile, and ordinary Python -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 582) modules. We don't want 'using foo' in Jamfile to load ordinary -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 583) Python module 'foo' which is going to not work. And we -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 584) also don't want 'import foo' in regular Python module to -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 585) accidentally grab module named foo that is internal to -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 586) Boost.Build and intended to provide interface to Jamfiles.""" -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 587) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 588) existing = self.loaded_tool_modules_.get(name) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 589) if existing: -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 590) return existing -53b0faa2 (jhunold 2008-08-10 18:25:50 +0000 591) -53b0faa2 (jhunold 2008-08-10 18:25:50 +0000 592) modules = sys.modules -53b0faa2 (jhunold 2008-08-10 18:25:50 +0000 593) for class_name in modules: -53b0faa2 (jhunold 2008-08-10 18:25:50 +0000 594) if name in class_name: -53b0faa2 (jhunold 2008-08-10 18:25:50 +0000 595) module = modules[class_name] -53b0faa2 (jhunold 2008-08-10 18:25:50 +0000 596) self.loaded_tool_modules_[name] = module -53b0faa2 (jhunold 2008-08-10 18:25:50 +0000 597) return module -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 598) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 599) path = extra_path -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 600) if not path: -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 601) path = [] -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 602) path.extend(self.manager.b2.path()) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 603) location = None -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 604) for p in path: -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 605) l = os.path.join(p, name + ".py") -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 606) if os.path.exists(l): -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 607) location = l -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 608) break -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 609) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 610) if not location: -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 611) self.manager.errors()("Cannot find module '%s'" % name) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 612) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 613) mname = "__build_build_temporary__" -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 614) file = open(location) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 615) try: -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 616) # TODO: this means we'll never make use of .pyc module, -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 617) # which might be a problem, or not. -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 618) module = imp.load_module(mname, file, os.path.basename(location), -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 619) (".py", "r", imp.PY_SOURCE)) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 620) del sys.modules[mname] -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 621) self.loaded_tool_modules_[name] = module -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 622) return module -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 623) finally: -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 624) file.close() -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 625) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 626) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 627) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 628) # FIXME: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 629) # Defines a Boost.Build extension project. Such extensions usually -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 630) # contain library targets and features that can be used by many people. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 631) # Even though extensions are really projects, they can be initialize as -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 632) # a module would be with the "using" (project.project-rules.using) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 633) # mechanism. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 634) #rule extension ( id : options * : * ) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 635) #{ -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 636) # # The caller is a standalone module for the extension. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 637) # local mod = [ CALLER_MODULE ] ; -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 638) # -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 639) # # We need to do the rest within the extension module. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 640) # module $(mod) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 641) # { -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 642) # import path ; -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 643) # -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 644) # # Find the root project. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 645) # local root-project = [ project.current ] ; -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 646) # root-project = [ $(root-project).project-module ] ; -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 647) # while -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 648) # [ project.attribute $(root-project) parent-module ] && -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 649) # [ project.attribute $(root-project) parent-module ] != user-config -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 650) # { -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 651) # root-project = [ project.attribute $(root-project) parent-module ] ; -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 652) # } -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 653) # -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 654) # # Create the project data, and bring in the project rules -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 655) # # into the module. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 656) # project.initialize $(__name__) : -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 657) # [ path.join [ project.attribute $(root-project) location ] ext $(1:L) ] ; -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 658) # -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 659) # # Create the project itself, i.e. the attributes. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 660) # # All extensions are created in the "/ext" project space. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 661) # project /ext/$(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ; -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 662) # local attributes = [ project.attributes $(__name__) ] ; -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 663) # -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 664) # # Inherit from the root project of whomever is defining us. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 665) # project.inherit-attributes $(__name__) : $(root-project) ; -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 666) # $(attributes).set parent-module : $(root-project) : exact ; -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 667) # } -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 668) #} -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 669) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 670) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 671) class ProjectAttributes: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 672) """Class keeping all the attributes of a project. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 673) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 674) The standard attributes are 'id', "location", "project-root", "parent" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 675) "requirements", "default-build", "source-location" and "projects-to-build". -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 676) """ -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 677) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 678) def __init__(self, manager, location, project_module): -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 679) self.manager = manager -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 680) self.location = location -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 681) self.project_module = project_module -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 682) self.attributes = {} -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 683) self.usage_requirements = None -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 684) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 685) def set(self, attribute, specification, exact): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 686) """Set the named attribute from the specification given by the user. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 687) The value actually set may be different.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 688) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 689) if exact: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 690) self.__dict__[attribute] = specification -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 691) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 692) elif attribute == "requirements": -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 693) self.requirements = property_set.refine_from_user_input( -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 694) self.requirements, specification, -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 695) self.project_module, self.location) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 696) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 697) elif attribute == "usage-requirements": -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 698) unconditional = [] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 699) for p in specification: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 700) split = property.split_conditional(p) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 701) if split: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 702) unconditional.append(split[1]) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 703) else: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 704) unconditional.append(p) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 705) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 706) non_free = property.remove("free", unconditional) -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 707) if non_free: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 708) pass -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 709) # FIXME: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 710) #errors.error "usage-requirements" $(specification) "have non-free properties" $(non-free) ; -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 711) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 712) t = property.translate_paths(specification, self.location) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 713) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 714) existing = self.__dict__.get("usage-requirements") -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 715) if existing: -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 716) new = property_set.create(existing.raw() + t) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 717) else: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 718) new = property_set.create(t) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 719) self.__dict__["usage-requirements"] = new -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 720) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 721) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 722) elif attribute == "default-build": -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 723) self.__dict__["default-build"] = property_set.create(specification) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 724) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 725) elif attribute == "source-location": -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 726) source_location = [] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 727) for path in specification: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 728) source_location += os.path.join(self.location, path) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 729) self.__dict__["source-location"] = source_location -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 730) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 731) elif attribute == "build-dir": -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 732) self.__dict__["build-dir"] = os.path.join(self.location, specification) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 733) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 734) elif not attribute in ["id", "default-build", "location", -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 735) "source-location", "parent", -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 736) "projects-to-build", "project-root"]: -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 737) self.manager.errors()( -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 738) """Invalid project attribute '%s' specified -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 739) for project at '%s'""" % (attribute, self.location)) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 740) else: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 741) self.__dict__[attribute] = specification -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 742) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 743) def get(self, attribute): -cde6f09a (vladimir_prus 2007-10-19 23:12:33 +0000 744) return self.__dict__[attribute] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 745) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 746) def dump(self): -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 747) """Prints the project attributes.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 748) id = self.get("id") -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 749) if not id: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 750) id = "(none)" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 751) else: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 752) id = id[0] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 753) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 754) parent = self.get("parent") -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 755) if not parent: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 756) parent = "(none)" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 757) else: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 758) parent = parent[0] -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 759) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 760) print "'%s'" % id -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 761) print "Parent project:%s", parent -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 762) print "Requirements:%s", self.get("requirements") -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 763) print "Default build:%s", string.join(self.get("debuild-build")) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 764) print "Source location:%s", string.join(self.get("source-location")) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 765) print "Projects to build:%s", string.join(self.get("projects-to-build").sort()); -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 766) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 767) class ProjectRules: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 768) """Class keeping all rules that are made available to Jamfile.""" -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 769) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 770) def __init__(self, registry): -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 771) self.registry = registry -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 772) self.manager_ = registry.manager -38d984eb (vladimir_prus 2007-10-13 17:52:25 +0000 773) self.rules = {} -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 774) self.local_names = [x for x in self.__class__.__dict__ -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 775) if x not in ["__init__", "init_project", "add_rule", -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 776) "error_reporting_wrapper", "add_rule_for_type"]] -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 777) self.all_names_ = [x for x in self.local_names] -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 778) -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 779) def add_rule_for_type(self, type): -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 780) rule_name = type.lower(); -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 781) -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 782) def xpto (name, sources, requirements = [], default_build = None, usage_requirements = []): -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 783) return self.manager_.targets().create_typed_target( -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 784) type, self.registry.current(), name[0], sources, -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 785) requirements, default_build, usage_requirements) -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 786) -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 787) self.add_rule(type.lower(), xpto) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 788) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 789) def add_rule(self, name, callable): -38d984eb (vladimir_prus 2007-10-13 17:52:25 +0000 790) self.rules[name] = callable -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 791) self.all_names_.append(name) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 792) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 793) def all_names(self): -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 794) return self.all_names_ -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 795) -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 796) def call_and_report_errors(self, callable, *args): -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 797) result = None -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 798) try: -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 799) self.manager_.errors().push_jamfile_context() -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 800) result = callable(*args) -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 801) except ExceptionWithUserContext, e: -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 802) e.report() -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 803) except Exception, e: -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 804) try: -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 805) self.manager_.errors().handle_stray_exception (e) -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 806) except ExceptionWithUserContext, e: -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 807) e.report() -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 808) finally: -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 809) self.manager_.errors().pop_jamfile_context() -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 810) -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 811) return result -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 812) -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 813) def make_wrapper(self, callable): -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 814) """Given a free-standing function 'callable', return a new -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 815) callable that will call 'callable' and report all exceptins, -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 816) using 'call_and_report_errors'.""" -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 817) def wrapper(*args): -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 818) self.call_and_report_errors(callable, *args) -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 819) return wrapper -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 820) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 821) def init_project(self, project_module): -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 822) -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 823) for n in self.local_names: -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 824) # Using 'getattr' here gives us a bound method, -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 825) # while using self.__dict__[r] would give unbound one. -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 826) v = getattr(self, n) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 827) if callable(v): -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 828) if n == "import_": -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 829) n = "import" -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 830) else: -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 831) n = string.replace(n, "_", "-") -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 832) -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 833) bjam.import_rule(project_module, n, -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 834) self.make_wrapper(v)) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 835) -38d984eb (vladimir_prus 2007-10-13 17:52:25 +0000 836) for n in self.rules: -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 837) bjam.import_rule(project_module, n, -0317671e (vladimir_prus 2007-10-28 14:02:06 +0000 838) self.make_wrapper(self.rules[n])) -38d984eb (vladimir_prus 2007-10-13 17:52:25 +0000 839) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 840) def project(self, *args): -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 841) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 842) jamfile_module = self.registry.current().project_module() -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 843) attributes = self.registry.attributes(jamfile_module) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 844) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 845) id = None -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 846) if args and args[0]: -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 847) id = args[0][0] -092119e3 (vladimir_prus 2007-10-16 05:45:31 +0000 848) args = args[1:] -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 849) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 850) if id: -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 851) if id[0] != '/': -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 852) id = '/' + id -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 853) self.registry.register_id (id, jamfile_module) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 854) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 855) explicit_build_dir = None -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 856) for a in args: -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 857) if a: -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 858) attributes.set(a[0], a[1:], exact=0) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 859) if a[0] == "build-dir": -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 860) explicit_build_dir = a[1] -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 861) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 862) # If '--build-dir' is specified, change the build dir for the project. -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 863) if self.registry.global_build_dir: -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 864) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 865) location = attributes.get("location") -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 866) # Project with empty location is 'standalone' project, like -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 867) # user-config, or qt. It has no build dir. -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 868) # If we try to set build dir for user-config, we'll then -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 869) # try to inherit it, with either weird, or wrong consequences. -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 870) if location and location == attributes.get("project-root"): -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 871) # This is Jamroot. -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 872) if id: -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 873) if explicit_build_dir and os.path.isabs(explicit_build_dir): -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 874) self.register.manager.errors()( -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 875) """Absolute directory specified via 'build-dir' project attribute -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 876) Don't know how to combine that with the --build-dir option.""") -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 877) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 878) rid = id -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 879) if rid[0] == '/': -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 880) rid = rid[1:] -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 881) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 882) p = os.path.join(self.registry.global_build_dir, -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 883) rid, explicit_build_dir) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 884) attributes.set("build-dir", p, exact=1) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 885) elif explicit_build_dir: -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 886) self.registry.manager.errors()( -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 887) """When --build-dir is specified, the 'build-project' -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 888) attribute is allowed only for top-level 'project' invocations""") -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 889) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 890) def constant(self, name, value): -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 891) """Declare and set a project global constant. -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 892) Project global constants are normal variables but should -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 893) not be changed. They are applied to every child Jamfile.""" -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 894) m = "Jamfile</home/ghost/Work/Boost/boost-svn/tools/build/v2_python/python/tests/bjam/make>" -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 895) self.registry.current().add_constant(name[0], value) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 896) -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 897) def path_constant(self, name, value): -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 898) """Declare and set a project global constant, whose value is a path. The -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 899) path is adjusted to be relative to the invocation directory. The given -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 900) value path is taken to be either absolute, or relative to this project -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 901) root.""" -0ed8e16d (vladimir_prus 2007-10-13 21:34:05 +0000 902) self.registry.current().add_constant(name[0], value, path=1) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 903) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 904) def use_project(self, id, where): -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 905) # See comment in 'load' for explanation why we record the -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 906) # parameters as opposed to loading the project now. -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 907) m = self.registry.current().project_module(); -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 908) self.registry.used_projects[m].append((id, where)) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 909) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 910) def build_project(self, dir): -1674e2d9 (jhunold 2008-08-08 19:52:05 +0000 911) assert(isinstance(dir, list)) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 912) jamfile_module = self.registry.current().project_module() -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 913) attributes = self.registry.attributes(jamfile_module) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 914) now = attributes.get("projects-to-build") -1674e2d9 (jhunold 2008-08-08 19:52:05 +0000 915) attributes.set("projects-to-build", now + dir, exact=True) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 916) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 917) def explicit(self, target_names): -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 918) t = self.registry.current() -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 919) for n in target_names: -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 920) t.mark_target_as_explicit(n) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 921) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 922) def glob(self, wildcards, excludes=None): -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 923) return self.registry.glob_internal(self.registry.current(), -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 924) wildcards, excludes, "glob") -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 925) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 926) def glob_tree(self, wildcards, excludes=None): -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 927) bad = 0 -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 928) for p in wildcards: -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 929) if os.path.dirname(p): -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 930) bad = 1 -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 931) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 932) if excludes: -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 933) for p in excludes: -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 934) if os.path.dirname(p): -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 935) bad = 1 -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 936) -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 937) if bad: -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 938) self.registry.manager().errors()( -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 939) "The patterns to 'glob-tree' may not include directory") -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 940) return self.registry.glob_internal(self.registry.current(), -2a36874b (vladimir_prus 2007-10-14 07:20:55 +0000 941) wildcards, excludes, "glob_tree") -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 942) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 943) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 944) def using(self, toolset, *args): -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 945) # The module referred by 'using' can be placed in -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 946) # the same directory as Jamfile, and the user -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 947) # will expect the module to be found even though -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 948) # the directory is not in BOOST_BUILD_PATH. -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 949) # So temporary change the search path. -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 950) jamfile_module = self.registry.current().project_module() -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 951) attributes = self.registry.attributes(jamfile_module) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 952) location = attributes.get("location") -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 953) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 954) m = self.registry.load_module(toolset[0], [location]) -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 955) if not m.__dict__.has_key("init"): -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 956) self.registry.manager.errors()( -7da7f9c1 (vladimir_prus 2008-05-18 04:29:53 +0000 957) "Tool module '%s' does not define the 'init' method" % toolset[0]) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 958) m.init(*args) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 959) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 960) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 961) def import_(self, name, names_to_import=None, local_names=None): -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 962) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 963) name = name[0] -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 964) jamfile_module = self.registry.current().project_module() -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 965) attributes = self.registry.attributes(jamfile_module) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 966) location = attributes.get("location") -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 967) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 968) m = self.registry.load_module(name, [location]) -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 969) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 970) for f in m.__dict__: -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 971) v = m.__dict__[f] -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 972) if callable(v): -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 973) bjam.import_rule(jamfile_module, name + "." + f, v) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 974) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 975) if names_to_import: -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 976) if not local_names: -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 977) local_names = names_to_import -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 978) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 979) if len(names_to_import) != len(local_names): -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 980) self.registry.manager.errors()( -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 981) """The number of names to import and local names do not match.""") -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 982) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 983) for n, l in zip(names_to_import, local_names): -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 984) bjam.import_rule(jamfile_module, l, m.__dict__[n]) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 985) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 986) def conditional(self, condition, requirements): -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 987) """Calculates conditional requirements for multiple requirements -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 988) at once. This is a shorthand to be reduce duplication and to -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 989) keep an inline declarative syntax. For example: -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 990) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 991) lib x : x.cpp : [ conditional <toolset>gcc <variant>debug : -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 992) <define>DEBUG_EXCEPTION <define>DEBUG_TRACE ] ; -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 993) """ -f049766b (vladimir_prus 2007-10-10 09:31:06 +0000 994) -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 995) c = string.join(condition, ",") -f2aef897 (vladimir_prus 2007-10-14 09:19:52 +0000 996) return [c + ":" + r for r in requirements] diff --git a/jam-files/boost-build/build/project.jam b/jam-files/boost-build/build/project.jam deleted file mode 100644 index c9967613..00000000 --- a/jam-files/boost-build/build/project.jam +++ /dev/null @@ -1,1110 +0,0 @@ -# Copyright 2002, 2003 Dave Abrahams -# Copyright 2002, 2005, 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) - -# Implements project representation and loading. Each project is represented by: -# - a module where all the Jamfile content live. -# - an instance of 'project-attributes' class. -# (given a module name, can be obtained using the 'attributes' rule) -# - an instance of 'project-target' class (from targets.jam) -# (given a module name, can be obtained using the 'target' rule) -# -# Typically, projects are created as result of loading a Jamfile, which is done -# by rules 'load' and 'initialize', below. First, module for Jamfile is loaded -# and new project-attributes instance is created. Some rules necessary for -# project are added to the module (see 'project-rules' module) at the bottom of -# this file. Default project attributes are set (inheriting attributes of parent -# project, if it exists). After that the Jamfile is read. It can declare its own -# attributes using the 'project' rule which will be combined with any already -# set attributes. -# -# The 'project' rule can also declare a project id which will be associated with -# the project module. -# -# There can also be 'standalone' projects. They are created by calling -# 'initialize' on an arbitrary module and not specifying their location. After -# the call, the module can call the 'project' rule, declare main targets and -# behave as a regular project except that, since it is not associated with any -# location, it should not declare targets that are not prebuilt. -# -# The list of all loaded Jamfile is stored in the .project-locations variable. -# It is possible to obtain a module name for a location using the 'module-name' -# rule. Standalone projects are not recorded and can only be referenced using -# their project id. - -import "class" : new ; -import errors ; -import modules ; -import path ; -import print ; -import property-set ; -import sequence ; - - -# Loads the Jamfile at the given location. After loading, project global file -# and Jamfiles needed by the requested one will be loaded recursively. If the -# Jamfile at that location is loaded already, does nothing. Returns the project -# module for the Jamfile. -# -rule load ( jamfile-location ) -{ - if --debug-loading in [ modules.peek : ARGV ] - { - ECHO "Loading Jamfile at" '$(jamfile-location)' ; - } - - local module-name = [ module-name $(jamfile-location) ] ; - # If Jamfile is already loaded, don't try again. - if ! $(module-name) in $(.jamfile-modules) - { - load-jamfile $(jamfile-location) : $(module-name) ; - - # We want to make sure that child project are loaded only after parent - # projects. In particular, because parent projects define attributes - # which are inherited by children, and we don't want children to be - # loaded before parent has defined everything. - # - # While "build-project" and "use-project" can potentially refer to child - # projects from parent projects, we don't immediately load child - # projects when seeing those attributes. Instead, we record the minimal - # information to be used only later. - load-used-projects $(module-name) ; - } - return $(module-name) ; -} - - -rule load-used-projects ( module-name ) -{ - local used = [ modules.peek $(module-name) : .used-projects ] ; - local location = [ attribute $(module-name) location ] ; - import project ; - while $(used) - { - local id = $(used[1]) ; - local where = $(used[2]) ; - - project.use $(id) : [ path.root [ path.make $(where) ] $(location) ] ; - used = $(used[3-]) ; - } -} - - -# Note the use of character groups, as opposed to listing 'Jamroot' and -# 'jamroot'. With the latter, we would get duplicate matches on Windows and -# would have to eliminate duplicates. -JAMROOT ?= [ modules.peek : JAMROOT ] ; -JAMROOT ?= project-root.jam [Jj]amroot [Jj]amroot.jam ; - - -# Loads parent of Jamfile at 'location'. Issues an error if nothing is found. -# -rule load-parent ( location ) -{ - local found = [ path.glob-in-parents $(location) : $(JAMROOT) $(JAMFILE) ] ; - - if ! $(found) - { - ECHO error: Could not find parent for project at '$(location)' ; - EXIT error: Did not find Jamfile.jam or Jamroot.jam in any parent - directory. ; - } - - return [ load $(found[1]:D) ] ; -} - - -# Makes the specified 'module' act as if it were a regularly loaded Jamfile at -# 'location'. Reports an error if a Jamfile has already been loaded for that -# location. -# -rule act-as-jamfile ( module : location ) -{ - if [ module-name $(location) ] in $(.jamfile-modules) - { - errors.error "Jamfile was already loaded for '$(location)'" ; - } - # Set up non-default mapping from location to module. - .module.$(location) = $(module) ; - - # Add the location to the list of project locations so that we don't try to - # reload the same Jamfile in the future. - .jamfile-modules += [ module-name $(location) ] ; - - initialize $(module) : $(location) ; -} - - -# Returns the project module corresponding to the given project-id or plain -# directory name. Returns nothing if such a project can not be found. -# -rule find ( name : current-location ) -{ - local project-module ; - - # Try interpreting name as project id. - if [ path.is-rooted $(name) ] - { - project-module = $($(name).jamfile-module) ; - } - - if ! $(project-module) - { - local location = [ path.root [ path.make $(name) ] $(current-location) ] - ; - - # If no project is registered for the given location, try to load it. - # First see if we have a Jamfile. If not, then see if we might have a - # project root willing to act as a Jamfile. In that case, project root - # must be placed in the directory referred by id. - - project-module = [ module-name $(location) ] ; - if ! $(project-module) in $(.jamfile-modules) - { - if [ path.glob $(location) : $(JAMROOT) $(JAMFILE) ] - { - project-module = [ load $(location) ] ; - } - else - { - project-module = ; - } - } - } - - return $(project-module) ; -} - - -# Returns the name of the module corresponding to 'jamfile-location'. If no -# module corresponds to that location yet, associates the default module name -# with that location. -# -rule module-name ( jamfile-location ) -{ - if ! $(.module.$(jamfile-location)) - { - # Root the path, so that locations are always unambiguous. Without this, - # we can't decide if '../../exe/program1' and '.' are the same paths. - jamfile-location = [ path.root $(jamfile-location) [ path.pwd ] ] ; - .module.$(jamfile-location) = Jamfile<$(jamfile-location)> ; - } - return $(.module.$(jamfile-location)) ; -} - - -# Default patterns to search for the Jamfiles to use for build declarations. -# -JAMFILE = [ modules.peek : JAMFILE ] ; -JAMFILE ?= [Bb]uild.jam [Jj]amfile.v2 [Jj]amfile [Jj]amfile.jam ; - - -# Find the Jamfile at the given location. This returns the exact names of all -# the Jamfiles in the given directory. The optional parent-root argument causes -# this to search not the given directory but the ones above it up to the -# directory given in it. -# -rule find-jamfile ( - dir # The directory(s) to look for a Jamfile. - parent-root ? # Optional flag indicating to search for the parent Jamfile. - : no-errors ? - ) -{ - # Glob for all the possible Jamfiles according to the match pattern. - # - local jamfile-glob = ; - if $(parent-root) - { - if ! $(.parent-jamfile.$(dir)) - { - .parent-jamfile.$(dir) = [ path.glob-in-parents $(dir) : $(JAMFILE) - ] ; - } - jamfile-glob = $(.parent-jamfile.$(dir)) ; - } - else - { - if ! $(.jamfile.$(dir)) - { - .jamfile.$(dir) = [ path.glob $(dir) : $(JAMFILE) ] ; - } - jamfile-glob = $(.jamfile.$(dir)) ; - - } - - local jamfile-to-load = $(jamfile-glob) ; - # Multiple Jamfiles found in the same place. Warn about this and ensure we - # use only one of them. As a temporary convenience measure, if there is - # Jamfile.v2 among found files, suppress the warning and use it. - # - if $(jamfile-to-load[2-]) - { - local v2-jamfiles = [ MATCH (.*[Jj]amfile\\.v2)|(.*[Bb]uild\\.jam) : $(jamfile-to-load) ] ; - - if $(v2-jamfiles) && ! $(v2-jamfiles[2]) - { - jamfile-to-load = $(v2-jamfiles) ; - } - else - { - local jamfile = [ path.basename $(jamfile-to-load[1]) ] ; - ECHO "warning: Found multiple Jamfiles at '"$(dir)"'!" - "Loading the first one: '$(jamfile)'." ; - } - - jamfile-to-load = $(jamfile-to-load[1]) ; - } - - # Could not find it, error. - # - if ! $(no-errors) && ! $(jamfile-to-load) - { - errors.error Unable to load Jamfile. - : Could not find a Jamfile in directory '$(dir)'. - : Attempted to find it with pattern '"$(JAMFILE:J=" ")"'. - : Please consult the documentation at 'http://www.boost.org'. ; - } - - return $(jamfile-to-load) ; -} - - -# Load a Jamfile at the given directory. Returns nothing. Will attempt to load -# the file as indicated by the JAMFILE patterns. Effect of calling this rule -# twice with the same 'dir' is undefined. -# -local rule load-jamfile ( - dir # The directory of the project Jamfile. - : jamfile-module - ) -{ - # See if the Jamfile is where it should be. - # - local jamfile-to-load = [ path.glob $(dir) : $(JAMROOT) ] ; - if ! $(jamfile-to-load) - { - jamfile-to-load = [ find-jamfile $(dir) ] ; - } - - if $(jamfile-to-load[2]) - { - errors.error "Multiple Jamfiles found at '$(dir)'" - : "Filenames are: " $(jamfile-to-load:D=) ; - } - - # Now load the Jamfile in it's own context. - # The call to 'initialize' may load parent Jamfile, which might have - # 'use-project' statement that causes a second attempt to load the - # same project we're loading now. Checking inside .jamfile-modules - # prevents that second attempt from messing up. - if ! $(jamfile-module) in $(.jamfile-modules) - { - .jamfile-modules += $(jamfile-module) ; - - # Initialize the Jamfile module before loading. - # - initialize $(jamfile-module) : [ path.parent $(jamfile-to-load) ] - : $(jamfile-to-load:BS) ; - - local saved-project = $(.current-project) ; - - mark-as-user $(jamfile-module) ; - modules.load $(jamfile-module) : [ path.native $(jamfile-to-load) ] : . ; - if [ MATCH ($(JAMROOT)) : $(jamfile-to-load:BS) ] - { - jamfile = [ find-jamfile $(dir) : no-errors ] ; - if $(jamfile) - { - load-aux $(jamfile-module) : [ path.native $(jamfile) ] ; - } - } - - # Now do some checks. - if $(.current-project) != $(saved-project) - { - errors.error "The value of the .current-project variable has magically" - : "changed after loading a Jamfile. This means some of the targets" - : "might be defined in the wrong project." - : "after loading" $(jamfile-module) - : "expected value" $(saved-project) - : "actual value" $(.current-project) ; - } - - if $(.global-build-dir) - { - local id = [ attribute $(jamfile-module) id ] ; - local project-root = [ attribute $(jamfile-module) project-root ] ; - local location = [ attribute $(jamfile-module) location ] ; - - if $(location) && $(project-root) = $(dir) - { - # This is Jamroot. - if ! $(id) - { - ECHO "warning: the --build-dir option was specified" ; - ECHO "warning: but Jamroot at '$(dir)'" ; - ECHO "warning: specified no project id" ; - ECHO "warning: the --build-dir option will be ignored" ; - } - } - } - } -} - - -rule mark-as-user ( module-name ) -{ - if USER_MODULE in [ RULENAMES ] - { - USER_MODULE $(module-name) ; - } -} - - -rule load-aux ( module-name : file ) -{ - mark-as-user $(module-name) ; - - module $(module-name) - { - include $(2) ; - local rules = [ RULENAMES $(1) ] ; - IMPORT $(1) : $(rules) : $(1) : $(1).$(rules) ; - } -} - - -.global-build-dir = [ MATCH --build-dir=(.*) : [ modules.peek : ARGV ] ] ; -if $(.global-build-dir) -{ - # If the option is specified several times, take the last value. - .global-build-dir = [ path.make $(.global-build-dir[-1]) ] ; -} - - -# Initialize the module for a project. -# -rule initialize ( - module-name # The name of the project module. - : location ? # The location (directory) of the project to initialize. If - # not specified, a standalone project will be initialized. - : basename ? - ) -{ - if --debug-loading in [ modules.peek : ARGV ] - { - ECHO "Initializing project '$(module-name)'" ; - } - - # TODO: need to consider if standalone projects can do anything but define - # prebuilt targets. If so, we need to give it a more sensible "location", so - # that source paths are correct. - location ?= "" ; - # Create the module for the Jamfile first. - module $(module-name) - { - } - $(module-name).attributes = [ new project-attributes $(location) - $(module-name) ] ; - local attributes = $($(module-name).attributes) ; - - if $(location) - { - $(attributes).set source-location : [ path.make $(location) ] : exact ; - } - else if ! $(module-name) in test-config site-config user-config project-config - { - # This is a standalone project with known location. Set source location - # so that it can declare targets. This is intended so that you can put - # a .jam file in your sources and use it via 'using'. Standard modules - # (in 'tools' subdir) may not assume source dir is set. - local s = [ modules.binding $(module-name) ] ; - if ! $(s) - { - errors.error "Could not determine project location $(module-name)" ; - } - $(attributes).set source-location : $(s:D) : exact ; - } - - $(attributes).set requirements : [ property-set.empty ] : exact ; - $(attributes).set usage-requirements : [ property-set.empty ] : exact ; - - # Import rules common to all project modules from project-rules module, - # defined at the end of this file. - local rules = [ RULENAMES project-rules ] ; - IMPORT project-rules : $(rules) : $(module-name) : $(rules) ; - - local jamroot ; - - local parent-module ; - if $(module-name) = test-config - { - # No parent. - } - else if $(module-name) = site-config - { - parent-module = test-config ; - } - else if $(module-name) = user-config - { - parent-module = site-config ; - } - else if $(module-name) = project-config - { - parent-module = user-config ; - } - else - { - # We search for parent/project-root only if Jamfile was specified, i.e. - # if the project is not standalone. - if $(location) && ! [ MATCH ($(JAMROOT)) : $(basename) ] - { - parent-module = [ load-parent $(location) ] ; - } - else - { - # It's either jamroot or standalone project. If it's jamroot, - # inherit from user-config. - if $(location) - { - # If project-config module exist, inherit from it. - if $(project-config.attributes) - { - parent-module = project-config ; - } - else - { - parent-module = user-config ; - } - jamroot = true ; - } - } - } - - if $(parent-module) - { - inherit-attributes $(module-name) : $(parent-module) ; - $(attributes).set parent-module : $(parent-module) : exact ; - } - - if $(jamroot) - { - $(attributes).set project-root : $(location) : exact ; - } - - local parent ; - if $(parent-module) - { - parent = [ target $(parent-module) ] ; - } - - if ! $(.target.$(module-name)) - { - .target.$(module-name) = [ new project-target $(module-name) - : $(module-name) $(parent) - : [ attribute $(module-name) requirements ] ] ; - - if --debug-loading in [ modules.peek : ARGV ] - { - ECHO "Assigned project target" $(.target.$(module-name)) - "to '$(module-name)'" ; - } - } - - .current-project = [ target $(module-name) ] ; -} - - -# Make 'project-module' inherit attributes of project root and parent module. -# -rule inherit-attributes ( project-module : parent-module ) -{ - local attributes = $($(project-module).attributes) ; - local pattributes = [ attributes $(parent-module) ] ; - # Parent module might be locationless configuration module. - if [ modules.binding $(parent-module) ] - { - $(attributes).set parent : [ path.parent - [ path.make [ modules.binding $(parent-module) ] ] ] ; - } - local v = [ $(pattributes).get project-root ] ; - $(attributes).set project-root : $(v) : exact ; - $(attributes).set default-build - : [ $(pattributes).get default-build ] ; - $(attributes).set requirements - : [ $(pattributes).get requirements ] : exact ; - $(attributes).set usage-requirements - : [ $(pattributes).get usage-requirements ] : exact ; - - local parent-build-dir = [ $(pattributes).get build-dir ] ; - if $(parent-build-dir) - { - # Have to compute relative path from parent dir to our dir. Convert both - # paths to absolute, since we cannot find relative path from ".." to - # ".". - - local location = [ attribute $(project-module) location ] ; - local parent-location = [ attribute $(parent-module) location ] ; - - local pwd = [ path.pwd ] ; - local parent-dir = [ path.root $(parent-location) $(pwd) ] ; - local our-dir = [ path.root $(location) $(pwd) ] ; - $(attributes).set build-dir : [ path.join $(parent-build-dir) - [ path.relative $(our-dir) $(parent-dir) ] ] : exact ; - } -} - - -# Associate the given id with the given project module. -# -rule register-id ( id : module ) -{ - $(id).jamfile-module = $(module) ; -} - - -# Class keeping all the attributes of a project. -# -# The standard attributes are "id", "location", "project-root", "parent" -# "requirements", "default-build", "source-location" and "projects-to-build". -# -class project-attributes -{ - import property ; - import property-set ; - import errors ; - import path ; - import print ; - import sequence ; - import project ; - - rule __init__ ( location project-module ) - { - self.location = $(location) ; - self.project-module = $(project-module) ; - } - - # Set the named attribute from the specification given by the user. The - # value actually set may be different. - # - rule set ( attribute : specification * - : exact ? # Sets value from 'specification' without any processing. - ) - { - if $(exact) - { - self.$(attribute) = $(specification) ; - } - else if $(attribute) = "requirements" - { - local result = [ property-set.refine-from-user-input - $(self.requirements) : $(specification) - : $(self.project-module) : $(self.location) ] ; - - if $(result[1]) = "@error" - { - errors.error Requirements for project at '$(self.location)' - conflict with parent's. : Explanation: $(result[2-]) ; - } - else - { - self.requirements = $(result) ; - } - } - else if $(attribute) = "usage-requirements" - { - local unconditional ; - for local p in $(specification) - { - local split = [ property.split-conditional $(p) ] ; - split ?= nothing $(p) ; - unconditional += $(split[2]) ; - } - - local non-free = [ property.remove free : $(unconditional) ] ; - if $(non-free) - { - errors.error usage-requirements $(specification) have non-free - properties $(non-free) ; - } - local t = [ property.translate-paths $(specification) - : $(self.location) ] ; - if $(self.usage-requirements) - { - self.usage-requirements = [ property-set.create - [ $(self.usage-requirements).raw ] $(t) ] ; - } - else - { - self.usage-requirements = [ property-set.create $(t) ] ; - } - } - else if $(attribute) = "default-build" - { - self.default-build = [ property.make $(specification) ] ; - } - else if $(attribute) = "source-location" - { - self.source-location = ; - for local src-path in $(specification) - { - self.source-location += [ path.root [ path.make $(src-path) ] - $(self.location) ] ; - } - } - else if $(attribute) = "build-dir" - { - self.build-dir = [ path.root - [ path.make $(specification) ] $(self.location) ] ; - } - else if $(attribute) = "id" - { - id = [ path.root $(specification) / ] ; - project.register-id $(id) : $(self.project-module) ; - self.id = $(id) ; - } - else if ! $(attribute) in "default-build" "location" "parent" - "projects-to-build" "project-root" "source-location" - { - errors.error Invalid project attribute '$(attribute)' specified for - project at '$(self.location)' ; - } - else - { - self.$(attribute) = $(specification) ; - } - } - - # Returns the value of the given attribute. - # - rule get ( attribute ) - { - return $(self.$(attribute)) ; - } - - # Prints the project attributes. - # - rule print ( ) - { - local id = $(self.id) ; id ?= (none) ; - local parent = $(self.parent) ; parent ?= (none) ; - print.section "'"$(id)"'" ; - print.list-start ; - print.list-item "Parent project:" $(parent) ; - print.list-item "Requirements:" [ $(self.requirements).raw ] ; - print.list-item "Default build:" $(self.default-build) ; - print.list-item "Source location:" $(self.source-location) ; - print.list-item "Projects to build:" - [ sequence.insertion-sort $(self.projects-to-build) ] ; - print.list-end ; - } -} - - -# Returns the project which is currently being loaded. -# -rule current ( ) -{ - return $(.current-project) ; -} - - -# Temporarily changes the current project to 'project'. Should be followed by -# 'pop-current'. -# -rule push-current ( project ) -{ - .saved-current-project += $(.current-project) ; - .current-project = $(project) ; -} - - -rule pop-current ( ) -{ - .current-project = $(.saved-current-project[-1]) ; - .saved-current-project = $(.saved-current-project[1--2]) ; -} - - -# Returns the project-attribute instance for the specified Jamfile module. -# -rule attributes ( project ) -{ - return $($(project).attributes) ; -} - - -# Returns the value of the specified attribute in the specified Jamfile module. -# -rule attribute ( project attribute ) -{ - return [ $($(project).attributes).get $(attribute) ] ; -} - - -# Returns the project target corresponding to the 'project-module'. -# -rule target ( project-module ) -{ - if ! $(.target.$(project-module)) - { - .target.$(project-module) = [ new project-target $(project-module) - : $(project-module) - : [ attribute $(project-module) requirements ] ] ; - } - return $(.target.$(project-module)) ; -} - - -# Use/load a project. -# -rule use ( id : location ) -{ - local saved-project = $(.current-project) ; - local project-module = [ project.load $(location) ] ; - local declared-id = [ project.attribute $(project-module) id ] ; - - if ! $(declared-id) || $(declared-id) != $(id) - { - # The project at 'location' either has no id or that id is not equal to - # the 'id' parameter. - if $($(id).jamfile-module) && ( $($(id).jamfile-module) != - $(project-module) ) - { - errors.user-error Attempt to redeclare already existing project id - '$(id)' - location '$(location)' ; - } - $(id).jamfile-module = $(project-module) ; - } - .current-project = $(saved-project) ; -} - - -# Defines a Boost.Build extension project. Such extensions usually contain -# library targets and features that can be used by many people. Even though -# extensions are really projects, they can be initialized as a module would be -# with the "using" (project.project-rules.using) mechanism. -# -rule extension ( id : options * : * ) -{ - # The caller is a standalone module for the extension. - local mod = [ CALLER_MODULE ] ; - - # We need to do the rest within the extension module. - module $(mod) - { - import path ; - - # Find the root project. - local root-project = [ project.current ] ; - root-project = [ $(root-project).project-module ] ; - while - [ project.attribute $(root-project) parent-module ] && - [ project.attribute $(root-project) parent-module ] != user-config - { - root-project = [ project.attribute $(root-project) parent-module ] ; - } - - # Create the project data, and bring in the project rules into the - # module. - project.initialize $(__name__) : [ path.join [ project.attribute - $(root-project) location ] ext $(1:L) ] ; - - # Create the project itself, i.e. the attributes. All extensions are - # created in the "/ext" project space. - project /ext/$(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : - $(9) ; - local attributes = [ project.attributes $(__name__) ] ; - - # Inherit from the root project of whomever is defining us. - project.inherit-attributes $(__name__) : $(root-project) ; - $(attributes).set parent-module : $(root-project) : exact ; - } -} - - -rule glob-internal ( project : wildcards + : excludes * : rule-name ) -{ - local location = [ $(project).get source-location ] ; - - local result ; - local paths = [ path.$(rule-name) $(location) : - [ sequence.transform path.make : $(wildcards) ] : - [ sequence.transform path.make : $(excludes) ] ] ; - if $(wildcards:D) || $(rule-name) != glob - { - # The paths we have found are relative to the current directory, but the - # names specified in the sources list are assumed to be relative to the - # source directory of the corresponding project. So, just make the names - # absolute. - for local p in $(paths) - { - # If the path is below source location, use relative path. - # Otherwise, use full path just to avoid any ambiguities. - local rel = [ path.relative $(p) $(location) : no-error ] ; - if $(rel) = not-a-child - { - result += [ path.root $(p) [ path.pwd ] ] ; - } - else - { - result += $(rel) ; - } - } - } - else - { - # There were no wildcards in the directory path, so the files are all in - # the source directory of the project. Just drop the directory, instead - # of making paths absolute. - result = $(paths:D="") ; - } - - return $(result) ; -} - - -# This module defines rules common to all projects. -# -module project-rules -{ - rule using ( toolset-module : * ) - { - import toolset ; - import modules ; - import project ; - - # Temporarily change the search path so the module referred to by - # 'using' can be placed in the same directory as Jamfile. User will - # expect the module to be found even though the directory is not in - # BOOST_BUILD_PATH. - local x = [ modules.peek : BOOST_BUILD_PATH ] ; - local caller = [ CALLER_MODULE ] ; - local caller-location = [ modules.binding $(caller) ] ; - modules.poke : BOOST_BUILD_PATH : $(caller-location:D) $(x) ; - toolset.using $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ; - modules.poke : BOOST_BUILD_PATH : $(x) ; - - # The above might have clobbered .current-project. Restore the correct - # value. - modules.poke project : .current-project - : [ project.target $(caller) ] ; - } - - import modules ; - - rule import ( * : * : * ) - { - modules.import project ; - - local caller = [ CALLER_MODULE ] ; - local saved = [ modules.peek project : .current-project ] ; - module $(caller) - { - modules.import $(1) : $(2) : $(3) ; - } - modules.poke project : .current-project : $(saved) ; - } - - rule project ( id ? : options * : * ) - { - import errors ; - import path ; - import project ; - - local caller = [ CALLER_MODULE ] ; - local attributes = [ project.attributes $(caller) ] ; - if $(id) - { - $(attributes).set id : $(id) ; - } - - local explicit-build-dir ; - - for n in 2 3 4 5 6 7 8 9 - { - local option = $($(n)) ; - if $(option) - { - $(attributes).set $(option[1]) : $(option[2-]) ; - } - if $(option[1]) = "build-dir" - { - explicit-build-dir = [ path.make $(option[2-]) ] ; - } - } - - # If '--build-dir' is specified, change the build dir for the project. - local global-build-dir = - [ modules.peek project : .global-build-dir ] ; - - if $(global-build-dir) - { - local location = [ $(attributes).get location ] ; - # Project with an empty location is a 'standalone' project such as - # user-config or qt. It has no build dir. If we try to set build dir - # for user-config, we shall then try to inherit it, with either - # weird or wrong consequences. - if $(location) && $(location) = [ $(attributes).get project-root ] - { - # Re-read the project id, since it might have been changed in - # the project's attributes. - id = [ $(attributes).get id ] ; - # This is Jamroot. - if $(id) - { - if $(explicit-build-dir) && - [ path.is-rooted $(explicit-build-dir) ] - { - errors.user-error Absolute directory specified via - 'build-dir' project attribute : Do not know how to - combine that with the --build-dir option. ; - } - # Strip the leading slash from id. - local rid = [ MATCH /(.*) : $(id) ] ; - local p = [ path.join - $(global-build-dir) $(rid) $(explicit-build-dir) ] ; - - $(attributes).set build-dir : $(p) : exact ; - } - } - else - { - # Not Jamroot. - if $(explicit-build-dir) - { - errors.user-error When --build-dir is specified, the - 'build-dir' project : attribute is allowed only for - top-level 'project' invocations ; - } - } - } - } - - # Declare and set a project global constant. Project global constants are - # normal variables but should not be changed. They are applied to every - # child Jamfile. - # - rule constant ( - name # Variable name of the constant. - : value + # Value of the constant. - ) - { - import project ; - local caller = [ CALLER_MODULE ] ; - local p = [ project.target $(caller) ] ; - $(p).add-constant $(name) : $(value) ; - } - - # Declare and set a project global constant, whose value is a path. The path - # is adjusted to be relative to the invocation directory. The given value - # path is taken to be either absolute, or relative to this project root. - # - rule path-constant ( - name # Variable name of the constant. - : value + # Value of the constant. - ) - { - import project ; - local caller = [ CALLER_MODULE ] ; - local p = [ project.target $(caller) ] ; - $(p).add-constant $(name) : $(value) : path ; - } - - rule use-project ( id : where ) - { - import modules ; - # See comment in 'load' for explanation. - local caller = [ CALLER_MODULE ] ; - modules.poke $(caller) : .used-projects : - [ modules.peek $(caller) : .used-projects ] - $(id) $(where) ; - } - - rule build-project ( dir ) - { - import project ; - local caller = [ CALLER_MODULE ] ; - local attributes = [ project.attributes $(caller) ] ; - - local now = [ $(attributes).get projects-to-build ] ; - $(attributes).set projects-to-build : $(now) $(dir) ; - } - - rule explicit ( target-names * ) - { - import project ; - # If 'explicit' is used in a helper rule defined in Jamroot and - # inherited by children, then most of the time we want 'explicit' to - # operate on the Jamfile where the helper rule is invoked. - local t = [ project.current ] ; - for local n in $(target-names) - { - $(t).mark-target-as-explicit $(n) ; - } - } - - rule always ( target-names * ) - { - import project ; - local t = [ project.current ] ; - for local n in $(target-names) - { - $(t).mark-target-as-always $(n) ; - } - } - - rule glob ( wildcards + : excludes * ) - { - import project ; - return [ project.glob-internal [ project.current ] : $(wildcards) : - $(excludes) : glob ] ; - } - - rule glob-tree ( wildcards + : excludes * ) - { - import project ; - - if $(wildcards:D) || $(excludes:D) - { - errors.user-error The patterns to 'glob-tree' may not include - directory ; - } - return [ project.glob-internal [ project.current ] : $(wildcards) : - $(excludes) : glob-tree ] ; - } - - # Calculates conditional requirements for multiple requirements at once. - # This is a shorthand to reduce duplication and to keep an inline - # declarative syntax. For example: - # - # lib x : x.cpp : [ conditional <toolset>gcc <variant>debug : - # <define>DEBUG_EXCEPTION <define>DEBUG_TRACE ] ; - # - rule conditional ( condition + : requirements * ) - { - local condition = $(condition:J=,) ; - if [ MATCH (:) : $(condition) ] - { - return $(condition)$(requirements) ; - } - else - { - return $(condition):$(requirements) ; - } - } - - rule option ( name : value ) - { - if $(__name__) != site-config && $(__name__) != user-config && $(__name__) != project-config - { - import errors ; - errors.error "The 'option' rule may be used only in site-config or user-config" ; - } - import option ; - option.set $(name) : $(value) ; - } -} diff --git a/jam-files/boost-build/build/project.py b/jam-files/boost-build/build/project.py deleted file mode 100644 index 1e1e16fa..00000000 --- a/jam-files/boost-build/build/project.py +++ /dev/null @@ -1,1120 +0,0 @@ -# Status: ported. -# Base revision: 64488 - -# Copyright 2002, 2003 Dave Abrahams -# Copyright 2002, 2005, 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) - -# Implements project representation and loading. -# Each project is represented by -# - a module where all the Jamfile content live. -# - an instance of 'project-attributes' class. -# (given module name, can be obtained by 'attributes' rule) -# - an instance of 'project-target' class (from targets.jam) -# (given a module name, can be obtained by 'target' rule) -# -# Typically, projects are created as result of loading Jamfile, which is -# do by rules 'load' and 'initialize', below. First, module for Jamfile -# is loaded and new project-attributes instance is created. Some rules -# necessary for project are added to the module (see 'project-rules' module) -# at the bottom of this file. -# Default project attributes are set (inheriting attributes of parent project, if -# it exists). After that, Jamfile is read. It can declare its own attributes, -# via 'project' rule, which will be combined with already set attributes. -# -# -# The 'project' rule can also declare project id, which will be associated with -# the project module. -# -# There can also be 'standalone' projects. They are created by calling 'initialize' -# on arbitrary module, and not specifying location. After the call, the module can -# call 'project' rule, declare main target and behave as regular projects. However, -# since it's not associated with any location, it's better declare only prebuilt -# targets. -# -# The list of all loaded Jamfile is stored in variable .project-locations. It's possible -# to obtain module name for a location using 'module-name' rule. The standalone projects -# are not recorded, the only way to use them is by project id. - -import b2.util.path -from b2.build import property_set, property -from b2.build.errors import ExceptionWithUserContext -import b2.build.targets - -import bjam - -import re -import sys -import os -import string -import imp -import traceback -import b2.util.option as option - -from b2.util import record_jam_to_value_mapping, qualify_jam_action - -class ProjectRegistry: - - def __init__(self, manager, global_build_dir): - self.manager = manager - self.global_build_dir = global_build_dir - self.project_rules_ = ProjectRules(self) - - # The target corresponding to the project being loaded now - self.current_project = None - - # The set of names of loaded project modules - self.jamfile_modules = {} - - # Mapping from location to module name - self.location2module = {} - - # Mapping from project id to project module - self.id2module = {} - - # Map from Jamfile directory to parent Jamfile/Jamroot - # location. - self.dir2parent_jamfile = {} - - # Map from directory to the name of Jamfile in - # that directory (or None). - self.dir2jamfile = {} - - # Map from project module to attributes object. - self.module2attributes = {} - - # Map from project module to target for the project - self.module2target = {} - - # Map from names to Python modules, for modules loaded - # via 'using' and 'import' rules in Jamfiles. - self.loaded_tool_modules_ = {} - - self.loaded_tool_module_path_ = {} - - # Map from project target to the list of - # (id,location) pairs corresponding to all 'use-project' - # invocations. - # TODO: should not have a global map, keep this - # in ProjectTarget. - self.used_projects = {} - - self.saved_current_project = [] - - self.JAMROOT = self.manager.getenv("JAMROOT"); - - # Note the use of character groups, as opposed to listing - # 'Jamroot' and 'jamroot'. With the latter, we'd get duplicate - # matches on windows and would have to eliminate duplicates. - if not self.JAMROOT: - self.JAMROOT = ["project-root.jam", "[Jj]amroot", "[Jj]amroot.jam"] - - # Default patterns to search for the Jamfiles to use for build - # declarations. - self.JAMFILE = self.manager.getenv("JAMFILE") - - if not self.JAMFILE: - self.JAMFILE = ["[Bb]uild.jam", "[Jj]amfile.v2", "[Jj]amfile", - "[Jj]amfile.jam"] - - - def load (self, jamfile_location): - """Loads jamfile at the given location. After loading, project global - file and jamfile needed by the loaded one will be loaded recursively. - If the jamfile at that location is loaded already, does nothing. - Returns the project module for the Jamfile.""" - - absolute = os.path.join(os.getcwd(), jamfile_location) - absolute = os.path.normpath(absolute) - jamfile_location = b2.util.path.relpath(os.getcwd(), absolute) - - if "--debug-loading" in self.manager.argv(): - print "Loading Jamfile at '%s'" % jamfile_location - - - mname = self.module_name(jamfile_location) - # If Jamfile is already loaded, don't try again. - if not mname in self.jamfile_modules: - - self.load_jamfile(jamfile_location, mname) - - # We want to make sure that child project are loaded only - # after parent projects. In particular, because parent projects - # define attributes whch are inherited by children, and we don't - # want children to be loaded before parents has defined everything. - # - # While "build-project" and "use-project" can potentially refer - # to child projects from parent projects, we don't immediately - # load child projects when seing those attributes. Instead, - # we record the minimal information that will be used only later. - - self.load_used_projects(mname) - - return mname - - def load_used_projects(self, module_name): - # local used = [ modules.peek $(module-name) : .used-projects ] ; - used = self.used_projects[module_name] - - location = self.attribute(module_name, "location") - for u in used: - id = u[0] - where = u[1] - - self.use(id, os.path.join(location, where)) - - def load_parent(self, location): - """Loads parent of Jamfile at 'location'. - Issues an error if nothing is found.""" - - found = b2.util.path.glob_in_parents( - location, self.JAMROOT + self.JAMFILE) - - if not found: - print "error: Could not find parent for project at '%s'" % location - print "error: Did not find Jamfile or project-root.jam in any parent directory." - sys.exit(1) - - return self.load(os.path.dirname(found[0])) - - def act_as_jamfile(self, module, location): - """Makes the specified 'module' act as if it were a regularly loaded Jamfile - at 'location'. If Jamfile is already located for that location, it's an - error.""" - - if self.module_name(location) in self.jamfile_modules: - self.manager.errors()( - "Jamfile was already loaded for '%s'" % location) - - # Set up non-default mapping from location to module. - self.location2module[location] = module - - # Add the location to the list of project locations - # so that we don't try to load Jamfile in future - self.jamfile_modules.append(location) - - self.initialize(module, location) - - def find(self, name, current_location): - """Given 'name' which can be project-id or plain directory name, - return project module corresponding to that id or directory. - Returns nothing of project is not found.""" - - project_module = None - - # Try interpreting name as project id. - if name[0] == '/': - project_module = self.id2module.get(name) - - if not project_module: - location = os.path.join(current_location, name) - # If no project is registered for the given location, try to - # load it. First see if we have Jamfile. If not we might have project - # root, willing to act as Jamfile. In that case, project-root - # must be placed in the directory referred by id. - - project_module = self.module_name(location) - if not project_module in self.jamfile_modules: - if b2.util.path.glob([location], self.JAMROOT + self.JAMFILE): - project_module = self.load(location) - else: - project_module = None - - return project_module - - def module_name(self, jamfile_location): - """Returns the name of module corresponding to 'jamfile-location'. - If no module corresponds to location yet, associates default - module name with that location.""" - module = self.location2module.get(jamfile_location) - if not module: - # Root the path, so that locations are always umbiguious. - # Without this, we can't decide if '../../exe/program1' and '.' - # are the same paths, or not. - jamfile_location = os.path.realpath( - os.path.join(os.getcwd(), jamfile_location)) - module = "Jamfile<%s>" % jamfile_location - self.location2module[jamfile_location] = module - return module - - def find_jamfile (self, dir, parent_root=0, no_errors=0): - """Find the Jamfile at the given location. This returns the - exact names of all the Jamfiles in the given directory. The optional - parent-root argument causes this to search not the given directory - but the ones above it up to the directory given in it.""" - - # Glob for all the possible Jamfiles according to the match pattern. - # - jamfile_glob = None - if parent_root: - parent = self.dir2parent_jamfile.get(dir) - if not parent: - parent = b2.util.path.glob_in_parents(dir, - self.JAMFILE) - self.dir2parent_jamfile[dir] = parent - jamfile_glob = parent - else: - jamfile = self.dir2jamfile.get(dir) - if not jamfile: - jamfile = b2.util.path.glob([dir], self.JAMFILE) - self.dir2jamfile[dir] = jamfile - jamfile_glob = jamfile - - if len(jamfile_glob) > 1: - # Multiple Jamfiles found in the same place. Warn about this. - # And ensure we use only one of them. - # As a temporary convenience measure, if there's Jamfile.v2 amount - # found files, suppress the warning and use it. - # - pattern = "(.*[Jj]amfile\\.v2)|(.*[Bb]uild\\.jam)" - v2_jamfiles = [x for x in jamfile_glob if re.match(pattern, x)] - if len(v2_jamfiles) == 1: - jamfile_glob = v2_jamfiles - else: - print """warning: Found multiple Jamfiles at '%s'!""" % (dir) - for j in jamfile_glob: - print " -", j - print "Loading the first one" - - # Could not find it, error. - if not no_errors and not jamfile_glob: - self.manager.errors()( - """Unable to load Jamfile. -Could not find a Jamfile in directory '%s' -Attempted to find it with pattern '%s'. -Please consult the documentation at 'http://boost.org/boost-build2'.""" - % (dir, string.join(self.JAMFILE))) - - if jamfile_glob: - return jamfile_glob[0] - - def load_jamfile(self, dir, jamfile_module): - """Load a Jamfile at the given directory. Returns nothing. - Will attempt to load the file as indicated by the JAMFILE patterns. - Effect of calling this rule twice with the same 'dir' is underfined.""" - - # See if the Jamfile is where it should be. - is_jamroot = False - jamfile_to_load = b2.util.path.glob([dir], self.JAMROOT) - if not jamfile_to_load: - jamfile_to_load = self.find_jamfile(dir) - else: - if len(jamfile_to_load) > 1: - get_manager().errors()("Multiple Jamfiles found at '%s'\n" +\ - "Filenames are: %s" - % (dir, [os.path.basename(j) for j in jamfile_to_load])) - - is_jamroot = True - jamfile_to_load = jamfile_to_load[0] - - dir = os.path.dirname(jamfile_to_load) - if not dir: - dir = "." - - self.used_projects[jamfile_module] = [] - - # Now load the Jamfile in it's own context. - # The call to 'initialize' may load parent Jamfile, which might have - # 'use-project' statement that causes a second attempt to load the - # same project we're loading now. Checking inside .jamfile-modules - # prevents that second attempt from messing up. - if not jamfile_module in self.jamfile_modules: - self.jamfile_modules[jamfile_module] = True - - # Initialize the jamfile module before loading. - # - self.initialize(jamfile_module, dir, os.path.basename(jamfile_to_load)) - - saved_project = self.current_project - - bjam.call("load", jamfile_module, jamfile_to_load) - basename = os.path.basename(jamfile_to_load) - - if is_jamroot: - jamfile = self.find_jamfile(dir, no_errors=True) - if jamfile: - bjam.call("load", jamfile_module, jamfile) - - # Now do some checks - if self.current_project != saved_project: - self.manager.errors()( -"""The value of the .current-project variable -has magically changed after loading a Jamfile. -This means some of the targets might be defined a the wrong project. -after loading %s -expected value %s -actual value %s""" % (jamfile_module, saved_project, self.current_project)) - - if self.global_build_dir: - id = self.attributeDefault(jamfile_module, "id", None) - project_root = self.attribute(jamfile_module, "project-root") - location = self.attribute(jamfile_module, "location") - - if location and project_root == dir: - # This is Jamroot - if not id: - # FIXME: go via errors module, so that contexts are - # shown? - print "warning: the --build-dir option was specified" - print "warning: but Jamroot at '%s'" % dir - print "warning: specified no project id" - print "warning: the --build-dir option will be ignored" - - - def load_standalone(self, jamfile_module, file): - """Loads 'file' as standalone project that has no location - associated with it. This is mostly useful for user-config.jam, - which should be able to define targets, but although it has - some location in filesystem, we don't want any build to - happen in user's HOME, for example. - - The caller is required to never call this method twice on - the same file. - """ - - self.used_projects[jamfile_module] = [] - bjam.call("load", jamfile_module, file) - self.load_used_projects(jamfile_module) - - def is_jamroot(self, basename): - match = [ pat for pat in self.JAMROOT if re.match(pat, basename)] - if match: - return 1 - else: - return 0 - - def initialize(self, module_name, location=None, basename=None): - """Initialize the module for a project. - - module-name is the name of the project module. - location is the location (directory) of the project to initialize. - If not specified, stanalone project will be initialized - """ - - if "--debug-loading" in self.manager.argv(): - print "Initializing project '%s'" % module_name - - # TODO: need to consider if standalone projects can do anything but defining - # prebuilt targets. If so, we need to give more sensible "location", so that - # source paths are correct. - if not location: - location = "" - - attributes = ProjectAttributes(self.manager, location, module_name) - self.module2attributes[module_name] = attributes - - python_standalone = False - if location: - attributes.set("source-location", [location], exact=1) - elif not module_name in ["test-config", "site-config", "user-config", "project-config"]: - # This is a standalone project with known location. Set source location - # so that it can declare targets. This is intended so that you can put - # a .jam file in your sources and use it via 'using'. Standard modules - # (in 'tools' subdir) may not assume source dir is set. - module = sys.modules[module_name] - attributes.set("source-location", self.loaded_tool_module_path_[module_name], exact=1) - python_standalone = True - - attributes.set("requirements", property_set.empty(), exact=True) - attributes.set("usage-requirements", property_set.empty(), exact=True) - attributes.set("default-build", property_set.empty(), exact=True) - attributes.set("projects-to-build", [], exact=True) - attributes.set("project-root", None, exact=True) - attributes.set("build-dir", None, exact=True) - - self.project_rules_.init_project(module_name, python_standalone) - - jamroot = False - - parent_module = None; - if module_name == "test-config": - # No parent - pass - elif module_name == "site-config": - parent_module = "test-config" - elif module_name == "user-config": - parent_module = "site-config" - elif module_name == "project-config": - parent_module = "user-config" - elif location and not self.is_jamroot(basename): - # We search for parent/project-root only if jamfile was specified - # --- i.e - # if the project is not standalone. - parent_module = self.load_parent(location) - else: - # It's either jamroot, or standalone project. - # If it's jamroot, inherit from user-config. - if location: - # If project-config module exist, inherit from it. - if self.module2attributes.has_key("project-config"): - parent_module = "project-config" - else: - parent_module = "user-config" ; - - jamroot = True ; - - if parent_module: - self.inherit_attributes(module_name, parent_module) - attributes.set("parent-module", parent_module, exact=1) - - if jamroot: - attributes.set("project-root", location, exact=1) - - parent = None - if parent_module: - parent = self.target(parent_module) - - if not self.module2target.has_key(module_name): - target = b2.build.targets.ProjectTarget(self.manager, - module_name, module_name, parent, - self.attribute(module_name,"requirements"), - # FIXME: why we need to pass this? It's not - # passed in jam code. - self.attribute(module_name, "default-build")) - self.module2target[module_name] = target - - self.current_project = self.target(module_name) - - def inherit_attributes(self, project_module, parent_module): - """Make 'project-module' inherit attributes of project - root and parent module.""" - - attributes = self.module2attributes[project_module] - pattributes = self.module2attributes[parent_module] - - # Parent module might be locationless user-config. - # FIXME: - #if [ modules.binding $(parent-module) ] - #{ - # $(attributes).set parent : [ path.parent - # [ path.make [ modules.binding $(parent-module) ] ] ] ; - # } - - attributes.set("project-root", pattributes.get("project-root"), exact=True) - attributes.set("default-build", pattributes.get("default-build"), exact=True) - attributes.set("requirements", pattributes.get("requirements"), exact=True) - attributes.set("usage-requirements", - pattributes.get("usage-requirements"), exact=1) - - parent_build_dir = pattributes.get("build-dir") - - if parent_build_dir: - # Have to compute relative path from parent dir to our dir - # Convert both paths to absolute, since we cannot - # find relative path from ".." to "." - - location = attributes.get("location") - parent_location = pattributes.get("location") - - our_dir = os.path.join(os.getcwd(), location) - parent_dir = os.path.join(os.getcwd(), parent_location) - - build_dir = os.path.join(parent_build_dir, - os.path.relpath(our_dir, parent_dir)) - attributes.set("build-dir", build_dir, exact=True) - - def register_id(self, id, module): - """Associate the given id with the given project module.""" - self.id2module[id] = module - - def current(self): - """Returns the project which is currently being loaded.""" - return self.current_project - - def set_current(self, c): - self.current_project = c - - def push_current(self, project): - """Temporary changes the current project to 'project'. Should - be followed by 'pop-current'.""" - self.saved_current_project.append(self.current_project) - self.current_project = project - - def pop_current(self): - self.current_project = self.saved_current_project[-1] - del self.saved_current_project[-1] - - def attributes(self, project): - """Returns the project-attribute instance for the - specified jamfile module.""" - return self.module2attributes[project] - - def attribute(self, project, attribute): - """Returns the value of the specified attribute in the - specified jamfile module.""" - return self.module2attributes[project].get(attribute) - try: - return self.module2attributes[project].get(attribute) - except: - raise BaseException("No attribute '%s' for project" % (attribute, project)) - - def attributeDefault(self, project, attribute, default): - """Returns the value of the specified attribute in the - specified jamfile module.""" - return self.module2attributes[project].getDefault(attribute, default) - - def target(self, project_module): - """Returns the project target corresponding to the 'project-module'.""" - if not self.module2target.has_key(project_module): - self.module2target[project_module] = \ - b2.build.targets.ProjectTarget(project_module, project_module, - self.attribute(project_module, "requirements")) - - return self.module2target[project_module] - - def use(self, id, location): - # Use/load a project. - saved_project = self.current_project - project_module = self.load(location) - declared_id = self.attributeDefault(project_module, "id", "") - - if not declared_id or declared_id != id: - # The project at 'location' either have no id or - # that id is not equal to the 'id' parameter. - if self.id2module.has_key(id) and self.id2module[id] != project_module: - self.manager.errors()( -"""Attempt to redeclare already existing project id '%s' at location '%s'""" % (id, location)) - self.id2module[id] = project_module - - self.current_module = saved_project - - def add_rule(self, name, callable): - """Makes rule 'name' available to all subsequently loaded Jamfiles. - - Calling that rule wil relay to 'callable'.""" - self.project_rules_.add_rule(name, callable) - - def project_rules(self): - return self.project_rules_ - - def glob_internal(self, project, wildcards, excludes, rule_name): - location = project.get("source-location")[0] - - result = [] - callable = b2.util.path.__dict__[rule_name] - - paths = callable([location], wildcards, excludes) - has_dir = 0 - for w in wildcards: - if os.path.dirname(w): - has_dir = 1 - break - - if has_dir or rule_name != "glob": - result = [] - # The paths we've found are relative to current directory, - # but the names specified in sources list are assumed to - # be relative to source directory of the corresponding - # prject. Either translate them or make absolute. - - for p in paths: - rel = os.path.relpath(p, location) - # If the path is below source location, use relative path. - if not ".." in rel: - result.append(rel) - else: - # Otherwise, use full path just to avoid any ambiguities. - result.append(os.path.abspath(p)) - - else: - # There were not directory in wildcard, so the files are all - # in the source directory of the project. Just drop the - # directory, instead of making paths absolute. - result = [os.path.basename(p) for p in paths] - - return result - - def load_module(self, name, extra_path=None): - """Load a Python module that should be useable from Jamfiles. - - There are generally two types of modules Jamfiles might want to - use: - - Core Boost.Build. Those are imported using plain names, e.g. - 'toolset', so this function checks if we have module named - b2.package.module already. - - Python modules in the same directory as Jamfile. We don't - want to even temporary add Jamfile's directory to sys.path, - since then we might get naming conflicts between standard - Python modules and those. - """ - - # See if we loaded module of this name already - existing = self.loaded_tool_modules_.get(name) - if existing: - return existing - - # See if we have a module b2.whatever.<name>, where <name> - # is what is passed to this function - modules = sys.modules - for class_name in modules: - parts = class_name.split('.') - if name is class_name or parts[0] == "b2" \ - and parts[-1] == name.replace("-", "_"): - module = modules[class_name] - self.loaded_tool_modules_[name] = module - return module - - # Lookup a module in BOOST_BUILD_PATH - path = extra_path - if not path: - path = [] - path.extend(self.manager.boost_build_path()) - location = None - for p in path: - l = os.path.join(p, name + ".py") - if os.path.exists(l): - location = l - break - - if not location: - self.manager.errors()("Cannot find module '%s'" % name) - - mname = name + "__for_jamfile" - file = open(location) - try: - # TODO: this means we'll never make use of .pyc module, - # which might be a problem, or not. - self.loaded_tool_module_path_[mname] = location - module = imp.load_module(mname, file, os.path.basename(location), - (".py", "r", imp.PY_SOURCE)) - self.loaded_tool_modules_[name] = module - return module - finally: - file.close() - - - -# FIXME: -# Defines a Boost.Build extension project. Such extensions usually -# contain library targets and features that can be used by many people. -# Even though extensions are really projects, they can be initialize as -# a module would be with the "using" (project.project-rules.using) -# mechanism. -#rule extension ( id : options * : * ) -#{ -# # The caller is a standalone module for the extension. -# local mod = [ CALLER_MODULE ] ; -# -# # We need to do the rest within the extension module. -# module $(mod) -# { -# import path ; -# -# # Find the root project. -# local root-project = [ project.current ] ; -# root-project = [ $(root-project).project-module ] ; -# while -# [ project.attribute $(root-project) parent-module ] && -# [ project.attribute $(root-project) parent-module ] != user-config -# { -# root-project = [ project.attribute $(root-project) parent-module ] ; -# } -# -# # Create the project data, and bring in the project rules -# # into the module. -# project.initialize $(__name__) : -# [ path.join [ project.attribute $(root-project) location ] ext $(1:L) ] ; -# -# # Create the project itself, i.e. the attributes. -# # All extensions are created in the "/ext" project space. -# project /ext/$(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ; -# local attributes = [ project.attributes $(__name__) ] ; -# -# # Inherit from the root project of whomever is defining us. -# project.inherit-attributes $(__name__) : $(root-project) ; -# $(attributes).set parent-module : $(root-project) : exact ; -# } -#} - - -class ProjectAttributes: - """Class keeping all the attributes of a project. - - The standard attributes are 'id', "location", "project-root", "parent" - "requirements", "default-build", "source-location" and "projects-to-build". - """ - - def __init__(self, manager, location, project_module): - self.manager = manager - self.location = location - self.project_module = project_module - self.attributes = {} - self.usage_requirements = None - - def set(self, attribute, specification, exact=False): - """Set the named attribute from the specification given by the user. - The value actually set may be different.""" - - if exact: - self.__dict__[attribute] = specification - - elif attribute == "requirements": - self.requirements = property_set.refine_from_user_input( - self.requirements, specification, - self.project_module, self.location) - - elif attribute == "usage-requirements": - unconditional = [] - for p in specification: - split = property.split_conditional(p) - if split: - unconditional.append(split[1]) - else: - unconditional.append(p) - - non_free = property.remove("free", unconditional) - if non_free: - get_manager().errors()("usage-requirements %s have non-free properties %s" \ - % (specification, non_free)) - - t = property.translate_paths( - property.create_from_strings(specification, allow_condition=True), - self.location) - - existing = self.__dict__.get("usage-requirements") - if existing: - new = property_set.create(existing.all() + t) - else: - new = property_set.create(t) - self.__dict__["usage-requirements"] = new - - - elif attribute == "default-build": - self.__dict__["default-build"] = property_set.create(specification) - - elif attribute == "source-location": - source_location = [] - for path in specification: - source_location.append(os.path.join(self.location, path)) - self.__dict__["source-location"] = source_location - - elif attribute == "build-dir": - self.__dict__["build-dir"] = os.path.join(self.location, specification[0]) - - elif attribute == "id": - id = specification[0] - if id[0] != '/': - id = "/" + id - self.manager.projects().register_id(id, self.project_module) - self.__dict__["id"] = id - - elif not attribute in ["default-build", "location", - "source-location", "parent", - "projects-to-build", "project-root"]: - self.manager.errors()( -"""Invalid project attribute '%s' specified -for project at '%s'""" % (attribute, self.location)) - else: - self.__dict__[attribute] = specification - - def get(self, attribute): - return self.__dict__[attribute] - - def getDefault(self, attribute, default): - return self.__dict__.get(attribute, default) - - def dump(self): - """Prints the project attributes.""" - id = self.get("id") - if not id: - id = "(none)" - else: - id = id[0] - - parent = self.get("parent") - if not parent: - parent = "(none)" - else: - parent = parent[0] - - print "'%s'" % id - print "Parent project:%s", parent - print "Requirements:%s", self.get("requirements") - print "Default build:%s", string.join(self.get("debuild-build")) - print "Source location:%s", string.join(self.get("source-location")) - print "Projects to build:%s", string.join(self.get("projects-to-build").sort()); - -class ProjectRules: - """Class keeping all rules that are made available to Jamfile.""" - - def __init__(self, registry): - self.registry = registry - self.manager_ = registry.manager - self.rules = {} - self.local_names = [x for x in self.__class__.__dict__ - if x not in ["__init__", "init_project", "add_rule", - "error_reporting_wrapper", "add_rule_for_type", "reverse"]] - self.all_names_ = [x for x in self.local_names] - - def _import_rule(self, bjam_module, name, callable): - if hasattr(callable, "bjam_signature"): - bjam.import_rule(bjam_module, name, self.make_wrapper(callable), callable.bjam_signature) - else: - bjam.import_rule(bjam_module, name, self.make_wrapper(callable)) - - - def add_rule_for_type(self, type): - rule_name = type.lower().replace("_", "-") - - def xpto (name, sources = [], requirements = [], default_build = [], usage_requirements = []): - return self.manager_.targets().create_typed_target( - type, self.registry.current(), name[0], sources, - requirements, default_build, usage_requirements) - - self.add_rule(rule_name, xpto) - - def add_rule(self, name, callable): - self.rules[name] = callable - self.all_names_.append(name) - - # Add new rule at global bjam scope. This might not be ideal, - # added because if a jamroot does 'import foo' where foo calls - # add_rule, we need to import new rule to jamroot scope, and - # I'm lazy to do this now. - self._import_rule("", name, callable) - - def all_names(self): - return self.all_names_ - - def call_and_report_errors(self, callable, *args, **kw): - result = None - try: - self.manager_.errors().push_jamfile_context() - result = callable(*args, **kw) - except ExceptionWithUserContext, e: - e.report() - except Exception, e: - try: - self.manager_.errors().handle_stray_exception (e) - except ExceptionWithUserContext, e: - e.report() - finally: - self.manager_.errors().pop_jamfile_context() - - return result - - def make_wrapper(self, callable): - """Given a free-standing function 'callable', return a new - callable that will call 'callable' and report all exceptins, - using 'call_and_report_errors'.""" - def wrapper(*args, **kw): - return self.call_and_report_errors(callable, *args, **kw) - return wrapper - - def init_project(self, project_module, python_standalone=False): - - if python_standalone: - m = sys.modules[project_module] - - for n in self.local_names: - if n != "import_": - setattr(m, n, getattr(self, n)) - - for n in self.rules: - setattr(m, n, self.rules[n]) - - return - - for n in self.local_names: - # Using 'getattr' here gives us a bound method, - # while using self.__dict__[r] would give unbound one. - v = getattr(self, n) - if callable(v): - if n == "import_": - n = "import" - else: - n = string.replace(n, "_", "-") - - self._import_rule(project_module, n, v) - - for n in self.rules: - self._import_rule(project_module, n, self.rules[n]) - - def project(self, *args): - - jamfile_module = self.registry.current().project_module() - attributes = self.registry.attributes(jamfile_module) - - id = None - if args and args[0]: - id = args[0][0] - args = args[1:] - - if id: - attributes.set('id', [id]) - - explicit_build_dir = None - for a in args: - if a: - attributes.set(a[0], a[1:], exact=0) - if a[0] == "build-dir": - explicit_build_dir = a[1] - - # If '--build-dir' is specified, change the build dir for the project. - if self.registry.global_build_dir: - - location = attributes.get("location") - # Project with empty location is 'standalone' project, like - # user-config, or qt. It has no build dir. - # If we try to set build dir for user-config, we'll then - # try to inherit it, with either weird, or wrong consequences. - if location and location == attributes.get("project-root"): - # Re-read the project id, since it might have been changed in - # the project's attributes. - id = attributes.get('id') - - # This is Jamroot. - if id: - if explicit_build_dir and os.path.isabs(explicit_build_dir): - self.registry.manager.errors()( -"""Absolute directory specified via 'build-dir' project attribute -Don't know how to combine that with the --build-dir option.""") - - rid = id - if rid[0] == '/': - rid = rid[1:] - - p = os.path.join(self.registry.global_build_dir, rid) - if explicit_build_dir: - p = os.path.join(p, explicit_build_dir) - attributes.set("build-dir", p, exact=1) - elif explicit_build_dir: - self.registry.manager.errors()( -"""When --build-dir is specified, the 'build-dir' -attribute is allowed only for top-level 'project' invocations""") - - def constant(self, name, value): - """Declare and set a project global constant. - Project global constants are normal variables but should - not be changed. They are applied to every child Jamfile.""" - m = "Jamfile</home/ghost/Work/Boost/boost-svn/tools/build/v2_python/python/tests/bjam/make>" - self.registry.current().add_constant(name[0], value) - - def path_constant(self, name, value): - """Declare and set a project global constant, whose value is a path. The - path is adjusted to be relative to the invocation directory. The given - value path is taken to be either absolute, or relative to this project - root.""" - if len(value) > 1: - self.registry.manager.error()("path constant should have one element") - self.registry.current().add_constant(name[0], value[0], path=1) - - def use_project(self, id, where): - # See comment in 'load' for explanation why we record the - # parameters as opposed to loading the project now. - m = self.registry.current().project_module(); - self.registry.used_projects[m].append((id[0], where[0])) - - def build_project(self, dir): - assert(isinstance(dir, list)) - jamfile_module = self.registry.current().project_module() - attributes = self.registry.attributes(jamfile_module) - now = attributes.get("projects-to-build") - attributes.set("projects-to-build", now + dir, exact=True) - - def explicit(self, target_names): - self.registry.current().mark_targets_as_explicit(target_names) - - def always(self, target_names): - self.registry.current().mark_targets_as_alays(target_names) - - def glob(self, wildcards, excludes=None): - return self.registry.glob_internal(self.registry.current(), - wildcards, excludes, "glob") - - def glob_tree(self, wildcards, excludes=None): - bad = 0 - for p in wildcards: - if os.path.dirname(p): - bad = 1 - - if excludes: - for p in excludes: - if os.path.dirname(p): - bad = 1 - - if bad: - self.registry.manager.errors()( -"The patterns to 'glob-tree' may not include directory") - return self.registry.glob_internal(self.registry.current(), - wildcards, excludes, "glob_tree") - - - def using(self, toolset, *args): - # The module referred by 'using' can be placed in - # the same directory as Jamfile, and the user - # will expect the module to be found even though - # the directory is not in BOOST_BUILD_PATH. - # So temporary change the search path. - current = self.registry.current() - location = current.get('location') - - m = self.registry.load_module(toolset[0], [location]) - if not m.__dict__.has_key("init"): - self.registry.manager.errors()( - "Tool module '%s' does not define the 'init' method" % toolset[0]) - m.init(*args) - - # The above might have clobbered .current-project. Restore the correct - # value. - self.registry.set_current(current) - - def import_(self, name, names_to_import=None, local_names=None): - - name = name[0] - py_name = name - if py_name == "os": - py_name = "os_j" - jamfile_module = self.registry.current().project_module() - attributes = self.registry.attributes(jamfile_module) - location = attributes.get("location") - - saved = self.registry.current() - - m = self.registry.load_module(py_name, [location]) - - for f in m.__dict__: - v = m.__dict__[f] - f = f.replace("_", "-") - if callable(v): - qn = name + "." + f - self._import_rule(jamfile_module, qn, v) - record_jam_to_value_mapping(qualify_jam_action(qn, jamfile_module), v) - - - if names_to_import: - if not local_names: - local_names = names_to_import - - if len(names_to_import) != len(local_names): - self.registry.manager.errors()( -"""The number of names to import and local names do not match.""") - - for n, l in zip(names_to_import, local_names): - self._import_rule(jamfile_module, l, m.__dict__[n]) - - self.registry.set_current(saved) - - def conditional(self, condition, requirements): - """Calculates conditional requirements for multiple requirements - at once. This is a shorthand to be reduce duplication and to - keep an inline declarative syntax. For example: - - lib x : x.cpp : [ conditional <toolset>gcc <variant>debug : - <define>DEBUG_EXCEPTION <define>DEBUG_TRACE ] ; - """ - - c = string.join(condition, ",") - if c.find(":") != -1: - return [c + r for r in requirements] - else: - return [c + ":" + r for r in requirements] - - def option(self, name, value): - name = name[0] - if not name in ["site-config", "user-config", "project-config"]: - get_manager().errors()("The 'option' rule may be used only in site-config or user-config") - - option.set(name, value[0]) diff --git a/jam-files/boost-build/build/property-set.jam b/jam-files/boost-build/build/property-set.jam deleted file mode 100644 index 70fd90cd..00000000 --- a/jam-files/boost-build/build/property-set.jam +++ /dev/null @@ -1,481 +0,0 @@ -# Copyright 2003 Dave Abrahams -# Copyright 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 "class" : new ; -import feature ; -import path ; -import project ; -import property ; -import sequence ; -import set ; -import option ; - -# Class for storing a set of properties. -# -# There is 1<->1 correspondence between identity and value. No two instances -# of the class are equal. To maintain this property, the 'property-set.create' -# rule should be used to create new instances. Instances are immutable. -# -# Each property is classified with regard to its effect on build results. -# Incidental properties have no effect on build results, from Boost.Build's -# point of view. Others are either free, or non-free and we refer to non-free -# ones as 'base'. Each property belongs to exactly one of those categories. -# -# It is possible to get a list of properties belonging to each category as -# well as a list of properties with a specific attribute. -# -# Several operations, like and refine and as-path are provided. They all use -# caching whenever possible. -# -class property-set -{ - import errors ; - import feature ; - import path ; - import property ; - import property-set ; - import set ; - - rule __init__ ( raw-properties * ) - { - self.raw = $(raw-properties) ; - - for local p in $(raw-properties) - { - if ! $(p:G) - { - errors.error "Invalid property: '$(p)'" ; - } - - local att = [ feature.attributes $(p:G) ] ; - # A feature can be both incidental and free, in which case we add it - # to incidental. - if incidental in $(att) - { - self.incidental += $(p) ; - } - else if free in $(att) - { - self.free += $(p) ; - } - else - { - self.base += $(p) ; - } - - if dependency in $(att) - { - self.dependency += $(p) ; - } - else - { - self.non-dependency += $(p) ; - } - - if [ MATCH (:) : $(p:G=) ] - { - self.conditional += $(p) ; - } - else - { - self.non-conditional += $(p) ; - } - - if propagated in $(att) - { - self.propagated += $(p) ; - } - if link-incompatible in $(att) - { - self.link-incompatible += $(p) ; - } - } - } - - # Returns Jam list of stored properties. - # - rule raw ( ) - { - return $(self.raw) ; - } - - rule str ( ) - { - return "[" $(self.raw) "]" ; - } - - # Returns properties that are neither incidental nor free. - # - rule base ( ) - { - return $(self.base) ; - } - - # Returns free properties which are not incidental. - # - rule free ( ) - { - return $(self.free) ; - } - - # Returns dependency properties. - # - rule dependency ( ) - { - return $(self.dependency) ; - } - - rule non-dependency ( ) - { - return $(self.non-dependency) ; - } - - rule conditional ( ) - { - return $(self.conditional) ; - } - - rule non-conditional ( ) - { - return $(self.non-conditional) ; - } - - # Returns incidental properties. - # - rule incidental ( ) - { - return $(self.incidental) ; - } - - rule refine ( ps ) - { - if ! $(self.refined.$(ps)) - { - local r = [ property.refine $(self.raw) : [ $(ps).raw ] ] ; - if $(r[1]) != "@error" - { - self.refined.$(ps) = [ property-set.create $(r) ] ; - } - else - { - self.refined.$(ps) = $(r) ; - } - } - return $(self.refined.$(ps)) ; - } - - rule expand ( ) - { - if ! $(self.expanded) - { - self.expanded = [ property-set.create [ feature.expand $(self.raw) ] ] ; - } - return $(self.expanded) ; - } - - rule expand-composites ( ) - { - if ! $(self.composites) - { - self.composites = [ property-set.create - [ feature.expand-composites $(self.raw) ] ] ; - } - return $(self.composites) ; - } - - rule evaluate-conditionals ( context ? ) - { - context ?= $(__name__) ; - if ! $(self.evaluated.$(context)) - { - self.evaluated.$(context) = [ property-set.create - [ property.evaluate-conditionals-in-context $(self.raw) : [ $(context).raw ] ] ] ; - } - return $(self.evaluated.$(context)) ; - } - - rule propagated ( ) - { - if ! $(self.propagated-ps) - { - self.propagated-ps = [ property-set.create $(self.propagated) ] ; - } - return $(self.propagated-ps) ; - } - - rule link-incompatible ( ) - { - if ! $(self.link-incompatible-ps) - { - self.link-incompatible-ps = - [ property-set.create $(self.link-incompatible) ] ; - } - return $(self.link-incompatible-ps) ; - } - - rule run-actions ( ) - { - if ! $(self.run) - { - self.run = [ property-set.create [ feature.run-actions $(self.raw) ] ] ; - } - return $(self.run) ; - } - - rule add-defaults ( ) - { - if ! $(self.defaults) - { - self.defaults = [ property-set.create - [ feature.add-defaults $(self.raw) ] ] ; - } - return $(self.defaults) ; - } - - rule as-path ( ) - { - if ! $(self.as-path) - { - self.as-path = [ property.as-path $(self.base) ] ; - } - return $(self.as-path) ; - } - - # Computes the path to be used for a target with the given properties. - # Returns a list of - # - the computed path - # - if the path is relative to the build directory, a value of 'true'. - # - rule target-path ( ) - { - if ! $(self.target-path) - { - # The <location> feature can be used to explicitly change the - # location of generated targets. - local l = [ get <location> ] ; - if $(l) - { - self.target-path = $(l) ; - } - else - { - local p = [ as-path ] ; - p = [ property-set.hash-maybe $(p) ] ; - - # A real 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 of '<location-prefix>' is prepended to the path. - local prefix = [ get <location-prefix> ] ; - if $(prefix) - { - self.target-path = [ path.join $(prefix) $(p) ] ; - } - else - { - self.target-path = $(p) ; - } - if ! $(self.target-path) - { - self.target-path = . ; - } - # The path is relative to build dir. - self.target-path += true ; - } - } - return $(self.target-path) ; - } - - rule add ( ps ) - { - if ! $(self.added.$(ps)) - { - self.added.$(ps) = [ property-set.create $(self.raw) [ $(ps).raw ] ] ; - } - return $(self.added.$(ps)) ; - } - - rule add-raw ( properties * ) - { - return [ add [ property-set.create $(properties) ] ] ; - } - - rule link-incompatible-with ( ps ) - { - if ! $(.li.$(ps)) - { - local li1 = [ $(__name__).link-incompatible ] ; - local li2 = [ $(ps).link-incompatible ] ; - if [ set.equal $(li1) : $(li2) ] - { - .li.$(ps) = false ; - } - else - { - .li.$(ps) = true ; - } - } - if $(.li.$(ps)) = true - { - return true ; - } - else - { - return ; - } - } - - # Returns all values of 'feature'. - # - rule get ( feature ) - { - if ! $(self.map-built) - { - # For each feature, create a member var and assign all values to it. - # Since all regular member vars start with 'self', there will be no - # conflicts between names. - self.map-built = true ; - for local v in $(self.raw) - { - $(v:G) += $(v:G=) ; - } - } - return $($(feature)) ; - } -} - - -# Creates a new 'property-set' instance for the given raw properties or returns -# an already existing ones. -# -rule create ( raw-properties * ) -{ - raw-properties = [ sequence.unique - [ sequence.insertion-sort $(raw-properties) ] ] ; - - local key = $(raw-properties:J=-:E=) ; - - if ! $(.ps.$(key)) - { - .ps.$(key) = [ new property-set $(raw-properties) ] ; - } - return $(.ps.$(key)) ; -} -NATIVE_RULE property-set : create ; - - -# Creates a new 'property-set' instance after checking that all properties are -# valid and converting incidental properties into gristed form. -# -rule create-with-validation ( raw-properties * ) -{ - property.validate $(raw-properties) ; - return [ create [ property.make $(raw-properties) ] ] ; -} - - -# Creates a property-set from the input given by the user, in the context of -# 'jamfile-module' at 'location'. -# -rule create-from-user-input ( raw-properties * : jamfile-module location ) -{ - local specification = [ property.translate-paths $(raw-properties) - : $(location) ] ; - specification = [ property.translate-indirect $(specification) - : $(jamfile-module) ] ; - local project-id = [ project.attribute $(jamfile-module) id ] ; - project-id ?= [ path.root $(location) [ path.pwd ] ] ; - specification = [ property.translate-dependencies - $(specification) : $(project-id) : $(location) ] ; - specification = - [ property.expand-subfeatures-in-conditions $(specification) ] ; - specification = [ property.make $(specification) ] ; - return [ property-set.create $(specification) ] ; -} - - -# Refines requirements with requirements provided by the user. Specially handles -# "-<property>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 user. -# - project-module -- module to which context indirect features will be -# bound. -# - location -- path to which path features are relative. -# -rule refine-from-user-input ( parent-requirements : specification * : - project-module : location ) -{ - if ! $(specification) - { - return $(parent-requirements) ; - } - else - { - local add-requirements ; - local remove-requirements ; - - for local r in $(specification) - { - local m = [ MATCH "^-(.*)" : $(r) ] ; - if $(m) - { - remove-requirements += $(m) ; - } - else - { - add-requirements += $(r) ; - } - } - - if $(remove-requirements) - { - # Need to create a property set, so that path features and indirect - # features are translated just like they are in project - # requirements. - local ps = [ property-set.create-from-user-input - $(remove-requirements) : $(project-module) $(location) ] ; - - parent-requirements = [ property-set.create - [ set.difference [ $(parent-requirements).raw ] - : [ $(ps).raw ] ] ] ; - specification = $(add-requirements) ; - } - - local requirements = [ property-set.create-from-user-input - $(specification) : $(project-module) $(location) ] ; - - return [ $(parent-requirements).refine $(requirements) ] ; - } -} - - -# Returns a property-set with an empty set of properties. -# -rule empty ( ) -{ - if ! $(.empty) - { - .empty = [ create ] ; - } - return $(.empty) ; -} - -if [ option.get hash : : yes ] = yes -{ - rule hash-maybe ( path ? ) - { - path ?= "" ; - return [ MD5 $(path) ] ; - } -} -else -{ - rule hash-maybe ( path ? ) - { - return $(path) ; - } -} - diff --git a/jam-files/boost-build/build/property.jam b/jam-files/boost-build/build/property.jam deleted file mode 100644 index a2ad5226..00000000 --- a/jam-files/boost-build/build/property.jam +++ /dev/null @@ -1,788 +0,0 @@ -# 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 errors ; -import feature ; -import indirect ; -import path ; -import regex ; -import string ; -import sequence ; -import set ; -import utility ; - - -# Refines 'properties' by overriding any non-free and non-conditional properties -# for which a different value is specified in 'requirements'. Returns the -# resulting list of properties. -# -rule refine ( properties * : requirements * ) -{ - local result ; - local error ; - - # All the 'requirements' elements should be present in the result. Record - # them so that we can handle 'properties'. - for local r in $(requirements) - { - # Do not consider conditional requirements. - if ! [ MATCH (:) : $(r:G=) ] - { - # Note: cannot use a local variable here, so use an ugly name. - __require__$(r:G) = $(r:G=) ; - } - } - - for local p in $(properties) - { - if [ MATCH (:) : $(p:G=) ] - { - # Do not modify conditional properties. - result += $(p) ; - } - else if free in [ feature.attributes $(p:G) ] - { - # Do not modify free properties. - result += $(p) ; - } - else - { - local required-value = $(__require__$(p:G)) ; - if $(required-value) - { - if $(p:G=) != $(required-value) - { - result += $(p:G)$(required-value) ; - } - else - { - result += $(p) ; - } - } - else - { - result += $(p) ; - } - } - } - - # Unset our ugly map. - for local r in $(requirements) - { - __require__$(r:G) = ; - } - - if $(error) - { - return $(error) ; - } - else - { - return [ sequence.unique $(result) $(requirements) ] ; - } -} - - -# Removes all conditional properties whose conditions are not met. For those -# with met conditions, removes the condition. Properties in conditions are -# looked up in 'context'. -# -rule evaluate-conditionals-in-context ( properties * : context * ) -{ - local base ; - local conditionals ; - for local p in $(properties) - { - if [ MATCH (:<) : $(p) ] - { - conditionals += $(p) ; - } - else - { - base += $(p) ; - } - } - - local result = $(base) ; - for local p in $(conditionals) - { - # Separate condition and property. - local s = [ MATCH (.*):(<.*) : $(p) ] ; - # Split condition into individual properties. - local condition = [ regex.split $(s[1]) "," ] ; - # Evaluate condition. - if ! [ MATCH (!).* : $(condition:G=) ] - { - # Only positive checks - if $(condition) in $(context) - { - result += $(s[2]) ; - } - } - else - { - # Have negative checks - local fail ; - while $(condition) - { - local c = $(condition[1]) ; - local m = [ MATCH !(.*) : $(c) ] ; - if $(m) - { - local p = $(m:G=$(c:G)) ; - if $(p) in $(context) - { - fail = true ; - c = ; - } - } - else - { - if ! $(c) in $(context) - { - fail = true ; - c = ; - } - } - condition = $(condition[2-]) ; - } - if ! $(fail) - { - result += $(s[2]) ; - } - } - } - return $(result) ; -} - - -rule expand-subfeatures-in-conditions ( properties * ) -{ - local result ; - for local p in $(properties) - { - local s = [ MATCH (.*):(<.*) : $(p) ] ; - if ! $(s) - { - result += $(p) ; - } - else - { - local condition = $(s[1]) ; - local value = $(s[2]) ; - # Condition might include several elements. - condition = [ regex.split $(condition) "," ] ; - local e ; - for local c in $(condition) - { - # It is common for a condition to include a toolset or - # subfeatures that have not been defined. In that case we want - # the condition to simply 'never be satisfied' and validation - # would only produce a spurious error so we prevent it by - # passing 'true' as the second parameter. - e += [ feature.expand-subfeatures $(c) : true ] ; - } - if $(e) = $(condition) - { - # (todo) - # This is just an optimization and possibly a premature one at - # that. - # (todo) (12.07.2008.) (Jurko) - result += $(p) ; - } - else - { - result += $(e:J=,):$(value) ; - } - } - } - return $(result) ; -} - - -# Helper for as-path, below. Orders properties with the implicit ones first, and -# within the two sections in alphabetical order of feature name. -# -local rule path-order ( x y ) -{ - if $(y:G) && ! $(x:G) - { - return true ; - } - else if $(x:G) && ! $(y:G) - { - return ; - } - else - { - if ! $(x:G) - { - x = [ feature.expand-subfeatures $(x) ] ; - y = [ feature.expand-subfeatures $(y) ] ; - } - - if $(x[1]) < $(y[1]) - { - return true ; - } - } -} - - -local rule abbreviate-dashed ( string ) -{ - local r ; - for local part in [ regex.split $(string) - ] - { - r += [ string.abbreviate $(part) ] ; - } - return $(r:J=-) ; -} - - -local rule identity ( string ) -{ - return $(string) ; -} - - -if --abbreviate-paths in [ modules.peek : ARGV ] -{ - .abbrev = abbreviate-dashed ; -} -else -{ - .abbrev = identity ; -} - - -# Returns a path representing the given expanded property set. -# -rule as-path ( properties * ) -{ - local entry = .result.$(properties:J=-) ; - - if ! $($(entry)) - { - # Trim redundancy. - properties = [ feature.minimize $(properties) ] ; - - # Sort according to path-order. - properties = [ sequence.insertion-sort $(properties) : path-order ] ; - - local components ; - for local p in $(properties) - { - if $(p:G) - { - local f = [ utility.ungrist $(p:G) ] ; - p = $(f)-$(p:G=) ; - } - components += [ $(.abbrev) $(p) ] ; - } - - $(entry) = $(components:J=/) ; - } - - return $($(entry)) ; -} - - -# Exit with error if property is not valid. -# -local rule validate1 ( property ) -{ - local msg ; - if $(property:G) - { - local feature = $(property:G) ; - local value = $(property:G=) ; - - if ! [ feature.valid $(feature) ] - { - # Ungrist for better error messages. - feature = [ utility.ungrist $(property:G) ] ; - msg = "unknown feature '$(feature)'" ; - } - else if $(value) && ! free in [ feature.attributes $(feature) ] - { - feature.validate-value-string $(feature) $(value) ; - } - else if ! ( $(value) || ( optional in [ feature.attributes $(feature) ] ) ) - { - # Ungrist for better error messages. - feature = [ utility.ungrist $(property:G) ] ; - msg = "No value specified for feature '$(feature)'" ; - } - } - else - { - local feature = [ feature.implied-feature $(property) ] ; - feature.validate-value-string $(feature) $(property) ; - } - if $(msg) - { - errors.error "Invalid property "'$(property:J=" ")'": "$(msg:J=" "). ; - } -} - - -rule validate ( properties * ) -{ - for local p in $(properties) - { - validate1 $(p) ; - } -} - - -rule validate-property-sets ( property-sets * ) -{ - for local s in $(property-sets) - { - validate [ feature.split $(s) ] ; - } -} - - -# Expands any implicit property values in the given property 'specification' so -# they explicitly state their feature. -# -rule make ( specification * ) -{ - local result ; - for local e in $(specification) - { - if $(e:G) - { - result += $(e) ; - } - else if [ feature.is-implicit-value $(e) ] - { - local feature = [ feature.implied-feature $(e) ] ; - result += $(feature)$(e) ; - } - else - { - errors.error "'$(e)' is not a valid property specification" ; - } - } - return $(result) ; -} - - -# Returns a property set containing all the elements in 'properties' that do not -# have their attributes listed in 'attributes'. -# -rule remove ( attributes + : properties * ) -{ - local result ; - for local e in $(properties) - { - if ! [ set.intersection $(attributes) : [ feature.attributes $(e:G) ] ] - { - result += $(e) ; - } - } - return $(result) ; -} - - -# Returns a property set containing all the elements in 'properties' that have -# their attributes listed in 'attributes'. -# -rule take ( attributes + : properties * ) -{ - local result ; - for local e in $(properties) - { - if [ set.intersection $(attributes) : [ feature.attributes $(e:G) ] ] - { - result += $(e) ; - } - } - return $(result) ; -} - - -# Selects properties corresponding to any of the given features. -# -rule select ( features * : properties * ) -{ - local result ; - - # Add any missing angle brackets. - local empty = "" ; - features = $(empty:G=$(features)) ; - - for local p in $(properties) - { - if $(p:G) in $(features) - { - result += $(p) ; - } - } - return $(result) ; -} - - -# Returns a modified version of properties with all values of the given feature -# replaced by the given value. If 'value' is empty the feature will be removed. -# -rule change ( properties * : feature value ? ) -{ - local result ; - for local p in $(properties) - { - if $(p:G) = $(feature) - { - result += $(value:G=$(feature)) ; - } - else - { - result += $(p) ; - } - } - return $(result) ; -} - - -# If 'property' is a conditional property, returns the condition and the -# property. E.g. <variant>debug,<toolset>gcc:<inlining>full will become -# <variant>debug,<toolset>gcc <inlining>full. Otherwise, returns an empty -# string. -# -rule split-conditional ( property ) -{ - local m = [ MATCH "(.+):<(.+)" : $(property) ] ; - if $(m) - { - return $(m[1]) <$(m[2]) ; - } -} - - -# 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. -# -rule translate-paths ( properties * : path ) -{ - local result ; - for local p in $(properties) - { - local split = [ split-conditional $(p) ] ; - local condition = "" ; - if $(split) - { - condition = $(split[1]): ; - p = $(split[2]) ; - } - - if path in [ feature.attributes $(p:G) ] - { - local values = [ regex.split $(p:TG=) "&&" ] ; - local t ; - for local v in $(values) - { - t += [ path.root [ path.make $(v) ] $(path) ] ; - } - t = $(t:J="&&") ; - result += $(condition)$(t:TG=$(p:G)) ; - } - else - { - result += $(condition)$(p) ; - } - } - return $(result) ; -} - - -# 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. -# Converts such values into 'indirect-rule' format (see indirect.jam), so they -# can be called from other modules. Does nothing for such values that are -# already in the 'indirect-rule' format. -# -rule translate-indirect ( specification * : context-module ) -{ - local result ; - for local p in $(specification) - { - local m = [ MATCH ^@(.+) : $(p:G=) ] ; - if $(m) - { - local v ; - if [ MATCH "^([^%]*)%([^%]+)$" : $(m) ] - { - # Rule is already in the 'indirect-rule' format. - v = $(m) ; - } - else - { - if ! [ MATCH ".*([.]).*" : $(m) ] - { - # This is an unqualified rule name. The user might want to - # set flags on this rule name and toolset.flag - # auto-qualifies it. Need to do the same here so flag - # setting works. We can arrange for toolset.flag to *not* - # auto-qualify the argument but then two rules defined in - # two Jamfiles would conflict. - m = $(context-module).$(m) ; - } - v = [ indirect.make $(m) : $(context-module) ] ; - } - - v = @$(v) ; - result += $(v:G=$(p:G)) ; - } - else - { - result += $(p) ; - } - } - return $(result) ; -} - - -# Binds all dependency properties in a list relative to the given project. -# Targets with absolute paths will be left unchanged and targets which have a -# project specified will have the path to the project interpreted relative to -# the specified location. -# -rule translate-dependencies ( specification * : project-id : location ) -{ - local result ; - for local p in $(specification) - { - local split = [ split-conditional $(p) ] ; - local condition = "" ; - if $(split) - { - condition = $(split[1]): ; - p = $(split[2]) ; - } - if dependency in [ feature.attributes $(p:G) ] - { - local split-target = [ regex.match (.*)//(.*) : $(p:G=) ] ; - if $(split-target) - { - local rooted = [ path.root [ path.make $(split-target[1]) ] - [ path.root $(location) [ path.pwd ] ] ] ; - result += $(condition)$(p:G)$(rooted)//$(split-target[2]) ; - } - else if [ path.is-rooted $(p:G=) ] - { - result += $(condition)$(p) ; - } - else - { - result += $(condition)$(p:G)$(project-id)//$(p:G=) ; - } - } - else - { - result += $(condition)$(p) ; - } - } - return $(result) ; -} - - -# Class maintaining a property set -> string mapping. -# -class property-map -{ - import errors ; - import numbers ; - import sequence ; - - rule __init__ ( ) - { - self.next-flag = 1 ; - } - - # Associate 'value' with 'properties'. - # - rule insert ( properties + : value ) - { - self.all-flags += $(self.next-flag) ; - self.properties.$(self.next-flag) = $(properties) ; - self.value.$(self.next-flag) = $(value) ; - - self.next-flag = [ numbers.increment $(self.next-flag) ] ; - } - - # Returns the value associated with 'properties' or any subset of it. If - # more than one subset has a value assigned to it, returns the value for the - # longest subset, if it is unique. - # - rule find ( properties + ) - { - return [ find-replace $(properties) ] ; - } - - # Returns the value associated with 'properties'. If 'value' parameter is - # given, replaces the found value. - # - rule find-replace ( properties + : value ? ) - { - # First find all matches. - local matches ; - local match-ranks ; - for local i in $(self.all-flags) - { - if $(self.properties.$(i)) in $(properties) - { - matches += $(i) ; - match-ranks += [ sequence.length $(self.properties.$(i)) ] ; - } - } - local best = [ sequence.select-highest-ranked $(matches) - : $(match-ranks) ] ; - if $(best[2]) - { - errors.error "Ambiguous key $(properties:J= :E=)" ; - } - local original = $(self.value.$(best)) ; - if $(value) - { - self.value.$(best) = $(value) ; - } - return $(original) ; - } -} - - -rule __test__ ( ) -{ - import assert ; - import "class" : new ; - import errors : try catch ; - import feature ; - - # Local rules must be explicitly re-imported. - import property : path-order abbreviate-dashed ; - - feature.prepare-test property-test-temp ; - - feature.feature toolset : gcc : implicit symmetric ; - feature.subfeature toolset gcc : version : 2.95.2 2.95.3 2.95.4 3.0 3.0.1 - 3.0.2 : optional ; - feature.feature define : : free ; - feature.feature runtime-link : dynamic static : symmetric link-incompatible ; - feature.feature optimization : on off ; - feature.feature variant : debug release : implicit composite symmetric ; - feature.feature rtti : on off : link-incompatible ; - - feature.compose <variant>debug : <define>_DEBUG <optimization>off ; - feature.compose <variant>release : <define>NDEBUG <optimization>on ; - - validate <toolset>gcc <toolset>gcc-3.0.1 : $(test-space) ; - - assert.true path-order $(test-space) debug <define>foo ; - assert.false path-order $(test-space) <define>foo debug ; - assert.true path-order $(test-space) gcc debug ; - assert.false path-order $(test-space) debug gcc ; - assert.true path-order $(test-space) <optimization>on <rtti>on ; - assert.false path-order $(test-space) <rtti>on <optimization>on ; - - assert.result-set-equal <toolset>gcc <rtti>off <define>FOO - : refine <toolset>gcc <rtti>off - : <define>FOO - : $(test-space) ; - - assert.result-set-equal <toolset>gcc <optimization>on - : refine <toolset>gcc <optimization>off - : <optimization>on - : $(test-space) ; - - assert.result-set-equal <toolset>gcc <rtti>off - : refine <toolset>gcc : <rtti>off : $(test-space) ; - - assert.result-set-equal <toolset>gcc <rtti>off <rtti>off:<define>FOO - : refine <toolset>gcc : <rtti>off <rtti>off:<define>FOO - : $(test-space) ; - - assert.result-set-equal <toolset>gcc:<define>foo <toolset>gcc:<define>bar - : refine <toolset>gcc:<define>foo : <toolset>gcc:<define>bar - : $(test-space) ; - - assert.result <define>MY_RELEASE - : evaluate-conditionals-in-context - <variant>release,<rtti>off:<define>MY_RELEASE - : <toolset>gcc <variant>release <rtti>off ; - - assert.result debug - : as-path <optimization>off <variant>debug - : $(test-space) ; - - assert.result gcc/debug/rtti-off - : as-path <toolset>gcc <optimization>off <rtti>off <variant>debug - : $(test-space) ; - - assert.result optmz-off : abbreviate-dashed optimization-off ; - assert.result rntm-lnk-sttc : abbreviate-dashed runtime-link-static ; - - try ; - validate <feature>value : $(test-space) ; - catch "Invalid property '<feature>value': unknown feature 'feature'." ; - - try ; - validate <rtti>default : $(test-space) ; - catch \"default\" is not a known value of feature <rtti> ; - - validate <define>WHATEVER : $(test-space) ; - - try ; - validate <rtti> : $(test-space) ; - catch "Invalid property '<rtti>': No value specified for feature 'rtti'." ; - - try ; - validate value : $(test-space) ; - catch "value" is not a value of an implicit feature ; - - assert.result-set-equal <rtti>on - : remove free implicit : <toolset>gcc <define>foo <rtti>on : $(test-space) ; - - assert.result-set-equal <include>a - : select include : <include>a <toolset>gcc ; - - assert.result-set-equal <include>a - : select include bar : <include>a <toolset>gcc ; - - assert.result-set-equal <include>a <toolset>gcc - : select include <bar> <toolset> : <include>a <toolset>gcc ; - - assert.result-set-equal <toolset>kylix <include>a - : change <toolset>gcc <include>a : <toolset> kylix ; - - pm = [ new property-map ] ; - $(pm).insert <toolset>gcc : o ; - $(pm).insert <toolset>gcc <os>NT : obj ; - $(pm).insert <toolset>gcc <os>CYGWIN : obj ; - - assert.equal o : [ $(pm).find <toolset>gcc ] ; - - assert.equal obj : [ $(pm).find <toolset>gcc <os>NT ] ; - - try ; - $(pm).find <toolset>gcc <os>NT <os>CYGWIN ; - catch "Ambiguous key <toolset>gcc <os>NT <os>CYGWIN" ; - - # Test ordinary properties. - assert.result : split-conditional <toolset>gcc ; - - # Test properties with ":". - assert.result : split-conditional <define>FOO=A::B ; - - # Test conditional feature. - assert.result-set-equal <toolset>gcc,<toolset-gcc:version>3.0 <define>FOO - : split-conditional <toolset>gcc,<toolset-gcc:version>3.0:<define>FOO ; - - feature.finish-test property-test-temp ; -} 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 - <variant>debug,<toolset>gcc:<inlining>full will become - <variant>debug,<toolset>gcc <inlining>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 <variant>debug : <define>_DEBUG <optimization>off ; -# compose <variant>release : <define>NDEBUG <optimization>on ; -# -# import assert ; -# import "class" : new ; -# -# validate <toolset>gcc <toolset>gcc-3.0.1 : $(test-space) ; -# -# assert.result <toolset>gcc <rtti>off <define>FOO -# : refine <toolset>gcc <rtti>off -# : <define>FOO -# : $(test-space) -# ; -# -# assert.result <toolset>gcc <optimization>on -# : refine <toolset>gcc <optimization>off -# : <optimization>on -# : $(test-space) -# ; -# -# assert.result <toolset>gcc <rtti>off -# : refine <toolset>gcc : <rtti>off : $(test-space) -# ; -# -# assert.result <toolset>gcc <rtti>off <rtti>off:<define>FOO -# : refine <toolset>gcc : <rtti>off <rtti>off:<define>FOO -# : $(test-space) -# ; -# -# assert.result <toolset>gcc:<define>foo <toolset>gcc:<define>bar -# : refine <toolset>gcc:<define>foo : <toolset>gcc:<define>bar -# : $(test-space) -# ; -# -# assert.result <define>MY_RELEASE -# : evaluate-conditionals-in-context -# <variant>release,<rtti>off:<define>MY_RELEASE -# : <toolset>gcc <variant>release <rtti>off -# -# ; -# -# try ; -# validate <feature>value : $(test-space) ; -# catch "Invalid property '<feature>value': unknown feature 'feature'." ; -# -# try ; -# validate <rtti>default : $(test-space) ; -# catch \"default\" is not a known value of feature <rtti> ; -# -# validate <define>WHATEVER : $(test-space) ; -# -# try ; -# validate <rtti> : $(test-space) ; -# catch "Invalid property '<rtti>': No value specified for feature 'rtti'." ; -# -# try ; -# validate value : $(test-space) ; -# catch "value" is not a value of an implicit feature ; -# -# -# assert.result <rtti>on -# : remove free implicit : <toolset>gcc <define>foo <rtti>on : $(test-space) ; -# -# assert.result <include>a -# : select include : <include>a <toolset>gcc ; -# -# assert.result <include>a -# : select include bar : <include>a <toolset>gcc ; -# -# assert.result <include>a <toolset>gcc -# : select include <bar> <toolset> : <include>a <toolset>gcc ; -# -# assert.result <toolset>kylix <include>a -# : change <toolset>gcc <include>a : <toolset> kylix ; -# -# # Test ordinary properties -# assert.result -# : split-conditional <toolset>gcc -# ; -# -# # Test properties with ":" -# assert.result -# : split-conditional <define>FOO=A::B -# ; -# -# # Test conditional feature -# assert.result <toolset>gcc,<toolset-gcc:version>3.0 <define>FOO -# : split-conditional <toolset>gcc,<toolset-gcc:version>3.0:<define>FOO -# ; -# -# feature.finish-test property-test-temp ; -# } -# - 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 "-<property>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 <location> feature can be used to explicitly - # change the location of generated targets - l = self.get ('<location>') - 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 '<location-prefix>' is predended to the path. - prefix = self.get ('<location-prefix>') - - if prefix: - if len (prefix) > 1: - raise AlreadyDefined ("Two <location-prefix> 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_ - diff --git a/jam-files/boost-build/build/readme.txt b/jam-files/boost-build/build/readme.txt deleted file mode 100644 index c3dddd8d..00000000 --- a/jam-files/boost-build/build/readme.txt +++ /dev/null @@ -1,13 +0,0 @@ -Copyright 2001, 2002 Dave Abrahams -Copyright 2002 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) - -Development code for new build system. To run unit tests for jam code, execute: - - bjam --debug --build-system=test - -Comprehensive tests require Python. See ../test/readme.txt - - - diff --git a/jam-files/boost-build/build/scanner.jam b/jam-files/boost-build/build/scanner.jam deleted file mode 100644 index d6042ea2..00000000 --- a/jam-files/boost-build/build/scanner.jam +++ /dev/null @@ -1,153 +0,0 @@ -# Copyright 2003 Dave Abrahams -# Copyright 2002, 2003, 2004, 2005 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) - -# Implements scanners: objects that compute implicit dependencies for -# files, such as includes in C++. -# -# Scanner has a regular expression used to find dependencies, some -# data needed to interpret those dependencies (for example, include -# paths), and a code which actually established needed relationship -# between actual jam targets. -# -# Scanner objects are created by actions, when they try to actualize -# virtual targets, passed to 'virtual-target.actualize' method and are -# then associated with actual targets. It is possible to use -# several scanners for a virtual-target. For example, a single source -# might be used by to compile actions, with different include paths. -# In this case, two different actual targets will be created, each -# having scanner of its own. -# -# Typically, scanners are created from target type and action's -# properties, using the rule 'get' in this module. Directly creating -# scanners is not recommended, because it might create many equvivalent -# but different instances, and lead in unneeded duplication of -# actual targets. However, actions can also create scanners in a special -# way, instead of relying on just target type. - -import "class" : new ; -import property virtual-target property-set ; -import errors : error ; - -# Base scanner class. -class scanner -{ - rule __init__ ( ) - { - } - - # Returns a pattern to use for scanning - rule pattern ( ) - { - error "method must be overriden" ; - } - - # Establish necessary relationship between targets, - # given actual target beeing scanned, and a list of - # pattern matches in that file. - rule process ( target : matches * ) - { - error "method must be overriden" ; - } -} - -# Registers a new generator class, specifying a set of -# properties relevant to this scanner. Ctor for that class -# should have one parameter: list of properties. -rule register ( scanner-class : relevant-properties * ) -{ - .registered += $(scanner-class) ; - .relevant-properties.$(scanner-class) = $(relevant-properties) ; -} - -# Common scanner class, which can be used when there's only one -# kind of includes (unlike C, where "" and <> includes have different -# search paths). -class common-scanner : scanner -{ - import scanner ; - rule __init__ ( includes * ) - { - scanner.__init__ ; - self.includes = $(includes) ; - } - - rule process ( target : matches * : binding ) - { - local target_path = [ NORMALIZE_PATH $(binding:D) ] ; - - NOCARE $(matches) ; - INCLUDES $(target) : $(matches) ; - SEARCH on $(matches) = $(target_path) $(self.includes:G=) ; - ISFILE $(matches) ; - - scanner.propagate $(__name__) : $(matches) : $(target) ; - } -} - - -# Returns an instance of previously registered scanner, -# with the specified properties. -rule get ( scanner-class : property-set ) -{ - if ! $(scanner-class) in $(.registered) - { - error "attempt to get unregisted scanner" ; - } - - local r = $(.rv-cache.$(property-set)) ; - if ! $(r) - { - r = [ property-set.create - [ property.select $(.relevant-properties.$(scanner-class)) : - [ $(property-set).raw ] ] ] ; - .rv-cache.$(property-set) = $(r) ; - } - - if ! $(scanner.$(scanner-class).$(r:J=-)) - { - scanner.$(scanner-class).$(r:J=-) = [ new $(scanner-class) [ $(r).raw ] ] ; - } - return $(scanner.$(scanner-class).$(r:J=-)) ; -} - - -# Installs the specified scanner on actual target 'target'. -rule install ( scanner : target - vtarget # virtual target from which 'target' was actualized -) -{ - HDRSCAN on $(target) = [ $(scanner).pattern ] ; - SCANNER on $(target) = $(scanner) ; - HDRRULE on $(target) = scanner.hdrrule ; - - # scanner reflects difference in properties affecting - # binding of 'target', which will be known when processing - # includes for it, will give information on how to - # interpret quoted includes. - HDRGRIST on $(target) = $(scanner) ; -} - -# Propagate scanner setting from 'including-target' to 'targets'. -rule propagate ( scanner : targets * : including-target ) -{ - HDRSCAN on $(targets) = [ on $(including-target) return $(HDRSCAN) ] ; - SCANNER on $(targets) = $(scanner) ; - HDRRULE on $(targets) = scanner.hdrrule ; - HDRGRIST on $(targets) = [ on $(including-target) return $(HDRGRIST) ] ; -} - - -rule hdrrule ( target : matches * : binding ) -{ - local scanner = [ on $(target) return $(SCANNER) ] ; - $(scanner).process $(target) : $(matches) : $(binding) ; -} -# hdrrule must be available at global scope so that it can be invoked -# by header scanning -IMPORT scanner : hdrrule : : scanner.hdrrule ; - - - - diff --git a/jam-files/boost-build/build/scanner.py b/jam-files/boost-build/build/scanner.py deleted file mode 100644 index 19f1431d..00000000 --- a/jam-files/boost-build/build/scanner.py +++ /dev/null @@ -1,158 +0,0 @@ -# Status: ported. -# Base revision: 45462 -# -# Copyright 2003 Dave Abrahams -# Copyright 2002, 2003, 2004, 2005 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) - -# Implements scanners: objects that compute implicit dependencies for -# files, such as includes in C++. -# -# Scanner has a regular expression used to find dependencies, some -# data needed to interpret those dependencies (for example, include -# paths), and a code which actually established needed relationship -# between actual jam targets. -# -# Scanner objects are created by actions, when they try to actualize -# virtual targets, passed to 'virtual-target.actualize' method and are -# then associated with actual targets. It is possible to use -# several scanners for a virtual-target. For example, a single source -# might be used by to compile actions, with different include paths. -# In this case, two different actual targets will be created, each -# having scanner of its own. -# -# Typically, scanners are created from target type and action's -# properties, using the rule 'get' in this module. Directly creating -# scanners is not recommended, because it might create many equvivalent -# but different instances, and lead in unneeded duplication of -# actual targets. However, actions can also create scanners in a special -# way, instead of relying on just target type. - -import property -import bjam -import os -from b2.exceptions import * -from b2.manager import get_manager - -def reset (): - """ Clear the module state. This is mainly for testing purposes. - """ - global __scanners, __rv_cache, __scanner_cache - - # Maps registered scanner classes to relevant properties - __scanners = {} - - # A cache of scanners. - # The key is: class_name.properties_tag, where properties_tag is the concatenation - # of all relevant properties, separated by '-' - __scanner_cache = {} - -reset () - - -def register(scanner_class, relevant_properties): - """ Registers a new generator class, specifying a set of - properties relevant to this scanner. Ctor for that class - should have one parameter: list of properties. - """ - __scanners[str(scanner_class)] = relevant_properties - -def registered(scanner_class): - """ Returns true iff a scanner of that class is registered - """ - return __scanners.has_key(str(scanner_class)) - -def get(scanner_class, properties): - """ Returns an instance of previously registered scanner - with the specified properties. - """ - scanner_name = str(scanner_class) - - if not registered(scanner_name): - raise BaseException ("attempt to get unregisted scanner: %s" % scanner_name) - - relevant_properties = __scanners[scanner_name] - r = property.select(relevant_properties, properties) - - scanner_id = scanner_name + '.' + '-'.join(r) - - if not __scanner_cache.has_key(scanner_name): - __scanner_cache[scanner_name] = scanner_class(r) - - return __scanner_cache[scanner_name] - -class Scanner: - """ Base scanner class. - """ - def __init__ (self): - pass - - def pattern (self): - """ Returns a pattern to use for scanning. - """ - raise BaseException ("method must be overriden") - - def process (self, target, matches): - """ Establish necessary relationship between targets, - given actual target beeing scanned, and a list of - pattern matches in that file. - """ - raise BaseException ("method must be overriden") - - -# Common scanner class, which can be used when there's only one -# kind of includes (unlike C, where "" and <> includes have different -# search paths). -class CommonScanner(Scanner): - - def __init__ (self, includes): - Scanner.__init__(self) - self.includes = includes - - def process(self, target, matches, binding): - - target_path = os.path.normpath(os.path.dirname(binding[0])) - bjam.call("mark-included", target, matches) - - get_manager().engine().set_target_variable(matches, "SEARCH", - [target_path] + self.includes) - get_manager().scanners().propagate(self, matches) - -class ScannerRegistry: - - def __init__ (self, manager): - self.manager_ = manager - self.count_ = 0 - self.exported_scanners_ = {} - - def install (self, scanner, target, vtarget): - """ Installs the specified scanner on actual target 'target'. - vtarget: virtual target from which 'target' was actualized. - """ - engine = self.manager_.engine() - engine.set_target_variable(target, "HDRSCAN", scanner.pattern()) - if not self.exported_scanners_.has_key(scanner): - exported_name = "scanner_" + str(self.count_) - self.count_ = self.count_ + 1 - self.exported_scanners_[scanner] = exported_name - bjam.import_rule("", exported_name, scanner.process) - else: - exported_name = self.exported_scanners_[scanner] - - engine.set_target_variable(target, "HDRRULE", exported_name) - - # scanner reflects difference in properties affecting - # binding of 'target', which will be known when processing - # includes for it, will give information on how to - # interpret quoted includes. - engine.set_target_variable(target, "HDRGRIST", str(id(scanner))) - pass - - def propagate(self, scanner, targets): - engine = self.manager_.engine() - engine.set_target_variable(targets, "HDRSCAN", scanner.pattern()) - engine.set_target_variable(targets, "HDRRULE", - self.exported_scanners_[scanner]) - engine.set_target_variable(targets, "HDRGRIST", str(id(scanner))) - diff --git a/jam-files/boost-build/build/targets.jam b/jam-files/boost-build/build/targets.jam deleted file mode 100644 index a70532ce..00000000 --- a/jam-files/boost-build/build/targets.jam +++ /dev/null @@ -1,1659 +0,0 @@ -# Copyright Vladimir Prus 2002. -# Copyright Rene Rivera 2006. -# -# Distributed under the Boost Software License, Version 1.0. -# (See accompanying file LICENSE_1_0.txt or copy at -# http://www.boost.org/LICENSE_1_0.txt) - -# Supports 'abstract' targets, which are targets explicitly defined in a -# Jamfile. -# -# Abstract targets are represented by classes derived from 'abstract-target' -# class. The first abstract target is 'project-target', which is created for -# each Jamfile, and can be obtained by the 'target' rule in the Jamfile's module -# (see project.jam). -# -# Project targets keep a list of 'main-target' instances. A main target is what -# the user explicitly defines in a Jamfile. It is possible to have several -# definitions for a main target, for example to have different lists of sources -# for different platforms. So, main targets keep a list of alternatives. -# -# Each alternative is an instance of 'abstract-target'. When a main target -# subvariant is defined by some rule, that rule will decide what class to use, -# create an instance of that class and add it to the list of alternatives for -# the main target. -# -# Rules supplied by the build system will use only targets derived from -# 'basic-target' class, which will provide some default behaviour. There will be -# different classes derived from it such as 'make-target', created by the 'make' -# rule, and 'typed-target', created by rules such as 'exe' and 'lib'. - -# -# +------------------------+ -# |abstract-target | -# +========================+ -# |name | -# |project | -# | | -# |generate(properties) = 0| -# +-----------+------------+ -# | -# ^ -# / \ -# +-+-+ -# | -# | -# +------------------------+------+------------------------------+ -# | | | -# | | | -# +----------+-----------+ +------+------+ +------+-------+ -# | project-target | | main-target | | basic-target | -# +======================+ 1 * +=============+ alternatives +==============+ -# | generate(properties) |o-----------+ generate |<>------------->| generate | -# | main-target | +-------------+ | construct = 0| -# +----------------------+ +--------------+ -# | -# ^ -# / \ -# +-+-+ -# | -# | -# ...--+----------------+------------------+----------------+---+ -# | | | | -# | | | | -# ... ---+-----+ +------+-------+ +------+------+ +--------+-----+ -# | | typed-target | | make-target | | stage-target | -# . +==============+ +=============+ +==============+ -# . | construct | | construct | | construct | -# +--------------+ +-------------+ +--------------+ - -import assert ; -import "class" : new ; -import errors ; -import feature ; -import indirect ; -import path ; -import property ; -import property-set ; -import sequence ; -import set ; -import toolset ; -import build-request ; - - -# Base class for all abstract targets. -# -class abstract-target -{ - import project ; - import assert ; - import "class" ; - import errors ; - - rule __init__ ( name # Name of the target in Jamfile. - : project-target # The project target to which this one belongs. - ) - { - # Note: it might seem that we don't need either name or project at all. - # However, there are places where we really need it. One example is - # error messages which should name problematic targets. Another is - # setting correct paths for sources and generated files. - - self.name = $(name) ; - self.project = $(project-target) ; - self.location = [ errors.nearest-user-location ] ; - } - - # Returns the name of this target. - rule name ( ) - { - return $(self.name) ; - } - - # Returns the project for this target. - rule project ( ) - { - return $(self.project) ; - } - - # Return the location where the target was declared. - rule location ( ) - { - return $(self.location) ; - } - - # Returns a user-readable name for this target. - rule full-name ( ) - { - local location = [ $(self.project).get location ] ; - return $(location)/$(self.name) ; - } - - # Generates virtual targets for this abstract target using the specified - # properties, unless a different value of some feature is required by the - # target. - # On success, returns: - # - a property-set with the usage requirements to be applied to dependants - # - a list of produced virtual targets, which may be empty. - # If 'property-set' is empty, performs the default build of this target, in - # a way specific to the derived class. - # - rule generate ( property-set ) - { - errors.error "method should be defined in derived classes" ; - } - - rule rename ( new-name ) - { - self.name = $(new-name) ; - } -} - - -if --debug-building in [ modules.peek : ARGV ] -{ - modules.poke : .debug-building : true ; -} - - -rule indent ( ) -{ - return $(.indent:J="") ; -} - - -rule increase-indent ( ) -{ - .indent += " " ; -} - - -rule decrease-indent ( ) -{ - .indent = $(.indent[2-]) ; -} - - -# Project target class (derived from 'abstract-target'). -# -# This class has the following responsibilities: -# - Maintaining a list of main targets in this project and building them. -# -# Main targets are constructed in two stages: -# - When Jamfile is read, a number of calls to 'add-alternative' is made. At -# that time, alternatives can also be renamed to account for inline targets. -# - The first time 'main-target' or 'has-main-target' rule is called, all -# alternatives are enumerated and main targets are created. -# -class project-target : abstract-target -{ - import project ; - import targets ; - import path ; - import print ; - import property-set ; - import set ; - import sequence ; - import "class" : new ; - import errors ; - - rule __init__ ( name : project-module parent-project ? - : requirements * : default-build * ) - { - abstract-target.__init__ $(name) : $(__name__) ; - - self.project-module = $(project-module) ; - self.location = [ project.attribute $(project-module) location ] ; - self.requirements = $(requirements) ; - self.default-build = $(default-build) ; - - if $(parent-project) - { - inherit $(parent-project) ; - } - } - - # This is needed only by the 'make' rule. Need to find the way to make - # 'make' work without this method. - # - rule project-module ( ) - { - return $(self.project-module) ; - } - - rule get ( attribute ) - { - return [ project.attribute $(self.project-module) $(attribute) ] ; - } - - rule build-dir ( ) - { - if ! $(self.build-dir) - { - self.build-dir = [ get build-dir ] ; - if ! $(self.build-dir) - { - self.build-dir = [ path.join [ $(self.project).get location ] - bin ] ; - } - } - return $(self.build-dir) ; - } - - # Generates all possible targets contained in this project. - # - rule generate ( property-set * ) - { - if [ modules.peek : .debug-building ] - { - ECHO [ targets.indent ] "building project" [ name ] " ('$(__name__)') with" [ $(property-set).raw ] ; - targets.increase-indent ; - } - - local usage-requirements = [ property-set.empty ] ; - local targets ; - - for local t in [ targets-to-build ] - { - local g = [ $(t).generate $(property-set) ] ; - usage-requirements = [ $(usage-requirements).add $(g[1]) ] ; - targets += $(g[2-]) ; - } - targets.decrease-indent ; - return $(usage-requirements) [ sequence.unique $(targets) ] ; - } - - # Computes and returns a list of abstract-target instances which must be - # built when this project is built. - # - rule targets-to-build ( ) - { - local result ; - - if ! $(self.built-main-targets) - { - build-main-targets ; - } - - # Collect all main targets here, except for "explicit" ones. - for local t in $(self.main-targets) - { - if ! [ $(t).name ] in $(self.explicit-targets) - { - result += $(t) ; - } - } - - # Collect all projects referenced via "projects-to-build" attribute. - local self-location = [ get location ] ; - for local pn in [ get projects-to-build ] - { - result += [ find $(pn)/ ] ; - } - - return $(result) ; - } - - # Add 'target' to the list of targets in this project that should be build - # only by explicit request - # - rule mark-target-as-explicit ( target-name * ) - { - # Record the name of the target, not instance, since this rule is called - # before main target instances are created. - self.explicit-targets += $(target-name) ; - } - - rule mark-target-as-always ( target-name * ) - { - # Record the name of the target, not instance, since this rule is called - # before main target instances are created. - self.always-targets += $(target-name) ; - } - - # Add new target alternative - # - rule add-alternative ( target-instance ) - { - if $(self.built-main-targets) - { - errors.error add-alternative called when main targets are already - created. : in project [ full-name ] ; - } - self.alternatives += $(target-instance) ; - } - - # Returns a 'main-target' class instance corresponding to 'name'. - # - rule main-target ( name ) - { - if ! $(self.built-main-targets) - { - build-main-targets ; - } - return $(self.main-target.$(name)) ; - } - - # Returns whether a main target with the specified name exists. - # - rule has-main-target ( name ) - { - if ! $(self.built-main-targets) - { - build-main-targets ; - } - - if $(self.main-target.$(name)) - { - return true ; - } - } - - # Worker function for the find rule not implementing any caching and simply - # returning nothing in case the target can not be found. - # - rule find-really ( id ) - { - local result ; - local current-location = [ get location ] ; - - local split = [ MATCH (.*)//(.*) : $(id) ] ; - local project-part = $(split[1]) ; - local target-part = $(split[2]) ; - - local extra-error-message ; - if $(project-part) - { - # There is an explicitly specified project part in id. Looks up the - # project and passes the request to it. - local pm = [ project.find $(project-part) : $(current-location) ] ; - if $(pm) - { - project-target = [ project.target $(pm) ] ; - result = [ $(project-target).find $(target-part) : no-error ] ; - } - else - { - # TODO: This extra error message will not get displayed most - # likely due to some buggy refactoring. Refactor the code so the - # message gets diplayed again. - extra-error-message = error: could not find project - '$(project-part)' ; - } - } - else - { - # Interpret target-name as name of main target. Need to do this - # before checking for file. Consider the following scenario with a - # toolset not modifying its executable's names, e.g. gcc on - # Unix-like platforms: - # - # exe test : test.cpp ; - # install s : test : <location>. ; - # - # After the first build we would have a target named 'test' in the - # Jamfile and a file named 'test' on the disk. We need the target to - # override the file. - result = [ main-target $(id) ] ; - - # Interpret id as an existing file reference. - if ! $(result) - { - result = [ new file-reference [ path.make $(id) ] : - $(self.project) ] ; - if ! [ $(result).exists ] - { - result = ; - } - } - - # Interpret id as project-id. - if ! $(result) - { - local project-module = [ project.find $(id) : - $(current-location) ] ; - if $(project-module) - { - result = [ project.target $(project-module) ] ; - } - } - } - - return $(result) ; - } - - # Find and return the target with the specified id, treated relative to - # self. Id may specify either a target or a file name with the target taking - # priority. May report an error or return nothing if the target is not found - # depending on the 'no-error' parameter. - # - rule find ( id : no-error ? ) - { - local v = $(.id.$(id)) ; - if ! $(v) - { - v = [ find-really $(id) ] ; - if ! $(v) - { - v = none ; - } - .id.$(id) = $(v) ; - } - - if $(v) != none - { - return $(v) ; - } - else - { - if ! $(no-error) - { - local current-location = [ get location ] ; - ECHO "error: Unable to find file or target named" ; - ECHO "error: '$(id)'" ; - ECHO "error: referred from project at" ; - ECHO "error: '$(current-location)'" ; - ECHO $(extra-error-message) ; - EXIT ; - } - } - } - - rule build-main-targets ( ) - { - self.built-main-targets = true ; - for local a in $(self.alternatives) - { - local name = [ $(a).name ] ; - local target = $(self.main-target.$(name)) ; - if ! $(target) - { - local t = [ new main-target $(name) : $(self.project) ] ; - self.main-target.$(name) = $(t) ; - self.main-targets += $(t) ; - target = $(self.main-target.$(name)) ; - } - - if $(name) in $(self.always-targets) - { - $(a).always ; - } - - $(target).add-alternative $(a) ; - } - } - - # Accessor, add a constant. - # - rule add-constant ( - name # Variable name of the constant. - : value + # Value of the constant. - : type ? # Optional type of value. - ) - { - switch $(type) - { - case path : - local r ; - for local v in $(value) - { - local l = $(self.location) ; - if ! $(l) - { - # Project corresponding to config files do not have - # 'location' attribute, but do have source location. - # It might be more reasonable to make every project have - # a location and use some other approach to prevent buildable - # targets in config files, but that's for later. - l = [ get source-location ] ; - } - v = [ path.root [ path.make $(v) ] $(l) ] ; - # Now make the value absolute path. - v = [ path.root $(v) [ path.pwd ] ] ; - # Constants should be in platform-native form. - v = [ path.native $(v) ] ; - r += $(v) ; - } - value = $(r) ; - } - if ! $(name) in $(self.constants) - { - self.constants += $(name) ; - } - self.constant.$(name) = $(value) ; - # Inject the constant in the scope of the Jamroot module. - modules.poke $(self.project-module) : $(name) : $(value) ; - } - - rule inherit ( parent ) - { - for local c in [ modules.peek $(parent) : self.constants ] - { - # No need to pass the type. Path constants were converted to - # absolute paths already by parent. - add-constant $(c) - : [ modules.peek $(parent) : self.constant.$(c) ] ; - } - - # Import rules from parent. - local this-module = [ project-module ] ; - local parent-module = [ $(parent).project-module ] ; - # Do not import rules coming from 'project-rules' as they must be - # imported localized. - local user-rules = [ set.difference - [ RULENAMES $(parent-module) ] : - [ RULENAMES project-rules ] ] ; - IMPORT $(parent-module) : $(user-rules) : $(this-module) : $(user-rules) ; - EXPORT $(this-module) : $(user-rules) ; - } -} - - -# Helper rules to detect cycles in main target references. -# -local rule start-building ( main-target-instance ) -{ - if $(main-target-instance) in $(.targets-being-built) - { - local names ; - for local t in $(.targets-being-built) $(main-target-instance) - { - names += [ $(t).full-name ] ; - } - - errors.error "Recursion in main target references" - : "the following target are being built currently:" - : $(names) ; - } - .targets-being-built += $(main-target-instance) ; -} - - -local rule end-building ( main-target-instance ) -{ - .targets-being-built = $(.targets-being-built[1--2]) ; -} - - -# A named top-level target in Jamfile. -# -class main-target : abstract-target -{ - import assert ; - import errors ; - import feature ; - import print ; - import property-set ; - import sequence ; - import targets : start-building end-building ; - - rule __init__ ( name : project ) - { - abstract-target.__init__ $(name) : $(project) ; - } - - # Add a new alternative for this target - rule add-alternative ( target ) - { - local d = [ $(target).default-build ] ; - if $(self.alternatives) && ( $(self.default-build) != $(d) ) - { - errors.error "default build must be identical in all alternatives" - : "main target is" [ full-name ] - : "with" [ $(d).raw ] - : "differing from previous default build" [ $(self.default-build).raw ] ; - } - else - { - self.default-build = $(d) ; - } - self.alternatives += $(target) ; - } - - # Returns the best viable alternative for this property-set. See the - # documentation for selection rules. - # - local rule select-alternatives ( property-set debug ? ) - { - # When selecting alternatives we have to consider defaults, for example: - # lib l : l.cpp : <variant>debug ; - # lib l : l_opt.cpp : <variant>release ; - # won't work unless we add default value <variant>debug. - property-set = [ $(p).add-defaults ] ; - - # The algorithm: we keep the current best viable alternative. When we've - # got a new best viable alternative, we compare it with the current one. - - local best ; - local best-properties ; - - if $(self.alternatives[2-]) - { - local bad ; - local worklist = $(self.alternatives) ; - while $(worklist) && ! $(bad) - { - local v = $(worklist[1]) ; - local properties = [ $(v).match $(property-set) $(debug) ] ; - - if $(properties) != no-match - { - if ! $(best) - { - best = $(v) ; - best-properties = $(properties) ; - } - else - { - if $(properties) = $(best-properties) - { - bad = true ; - } - else if $(properties) in $(best-properties) - { - # Do nothing, this alternative is worse - } - else if $(best-properties) in $(properties) - { - best = $(v) ; - best-properties = $(properties) ; - } - else - { - bad = true ; - } - } - } - worklist = $(worklist[2-]) ; - } - if ! $(bad) - { - return $(best) ; - } - } - else - { - return $(self.alternatives) ; - } - } - - rule apply-default-build ( property-set ) - { - return [ targets.apply-default-build $(property-set) - : $(self.default-build) ] ; - } - - # Select an alternative for this main target, by finding all alternatives - # which requirements are satisfied by 'properties' and picking the one with - # the longest requirements set. Returns the result of calling 'generate' on - # that alternative. - # - rule generate ( property-set ) - { - start-building $(__name__) ; - - # We want composite properties in build request act as if all the - # properties it expands too are explicitly specified. - property-set = [ $(property-set).expand ] ; - - local all-property-sets = [ apply-default-build $(property-set) ] ; - local usage-requirements = [ property-set.empty ] ; - local result ; - for local p in $(all-property-sets) - { - local r = [ generate-really $(p) ] ; - if $(r) - { - usage-requirements = [ $(usage-requirements).add $(r[1]) ] ; - result += $(r[2-]) ; - } - } - end-building $(__name__) ; - return $(usage-requirements) [ sequence.unique $(result) ] ; - } - - # Generates the main target with the given property set and returns a list - # which first element is property-set object containing usage-requirements - # of generated target and with generated virtual target in other elements. - # It is possible that no targets are generated. - # - local rule generate-really ( property-set ) - { - local best-alternatives = [ select-alternatives $(property-set) ] ; - if ! $(best-alternatives) - { - ECHO "error: No best alternative for" [ full-name ] ; - select-alternatives $(property-set) debug ; - return [ property-set.empty ] ; - } - else - { - # Now return virtual targets for the only alternative. - return [ $(best-alternatives).generate $(property-set) ] ; - } - } - - rule rename ( new-name ) - { - abstract-target.rename $(new-name) ; - for local a in $(self.alternatives) - { - $(a).rename $(new-name) ; - } - } -} - - -# Abstract target refering to a source file. This is an artificial entity -# allowing sources to a target to be represented using a list of abstract target -# instances. -# -class file-reference : abstract-target -{ - import virtual-target ; - import property-set ; - import path ; - - rule __init__ ( file : project ) - { - abstract-target.__init__ $(file) : $(project) ; - } - - rule generate ( properties ) - { - return [ property-set.empty ] [ virtual-target.from-file $(self.name) : - [ location ] : $(self.project) ] ; - } - - # Returns true if the referred file really exists. - rule exists ( ) - { - location ; - return $(self.file-path) ; - } - - # Returns the location of target. Needed by 'testing.jam'. - rule location ( ) - { - if ! $(self.file-location) - { - local source-location = [ $(self.project).get source-location ] ; - for local src-dir in $(source-location) - { - if ! $(self.file-location) - { - local location = [ path.root $(self.name) $(src-dir) ] ; - if [ CHECK_IF_FILE [ path.native $(location) ] ] - { - self.file-location = $(src-dir) ; - self.file-path = $(location) ; - } - } - } - } - return $(self.file-location) ; - } -} - - -# Given a target-reference, made in context of 'project', returns the -# abstract-target instance that is referred to, as well as properties explicitly -# specified for this reference. -# -rule resolve-reference ( target-reference : project ) -{ - # Separate target name from properties override. - local split = [ MATCH "^([^<]*)(/(<.*))?$" : $(target-reference) ] ; - local id = $(split[1]) ; - local sproperties = ; - if $(split[3]) - { - sproperties = [ property.make [ feature.split $(split[3]) ] ] ; - sproperties = [ feature.expand-composites $(sproperties) ] ; - } - - # Find the target. - local target = [ $(project).find $(id) ] ; - - return $(target) [ property-set.create $(sproperties) ] ; -} - - -# Attempts to generate the target given by target reference, which can refer -# both to a main target or to a file. Returns a list consisting of -# - usage requirements -# - generated virtual targets, if any -# -rule generate-from-reference ( - target-reference # Target reference. - : project # Project where the reference is made. - : property-set # Properties of the main target that makes the reference. -) -{ - local r = [ resolve-reference $(target-reference) : $(project) ] ; - local target = $(r[1]) ; - local sproperties = $(r[2]) ; - - # Take properties which should be propagated and refine them with - # source-specific requirements. - local propagated = [ $(property-set).propagated ] ; - local rproperties = [ $(propagated).refine $(sproperties) ] ; - if $(rproperties[1]) = "@error" - { - errors.error - "When building" [ full-name ] " with properties " $(properties) : - "Invalid properties specified for " $(source) ":" - $(rproperties[2-]) ; - } - return [ $(target).generate $(rproperties) ] ; -} - -rule apply-default-build ( property-set : default-build ) -{ - # 1. First, see what properties from default-build are already present - # in property-set. - - local raw = [ $(property-set).raw ] ; - local specified-features = $(raw:G) ; - - local defaults-to-apply ; - for local d in [ $(default-build).raw ] - { - if ! $(d:G) in $(specified-features) - { - defaults-to-apply += $(d) ; - } - } - - # 2. If there are any defaults to be applied, form a new build request. - # Pass it through to 'expand-no-defaults' since default-build might - # contain "release debug" resulting in two property-sets. - local result ; - if $(defaults-to-apply) - { - properties = [ - build-request.expand-no-defaults - - # We have to compress subproperties here to prevent property - # lists like: - # - # <toolset>msvc <toolset-msvc:version>7.1 <threading>multi - # - # from being expanded into: - # - # <toolset-msvc:version>7.1/<threading>multi - # <toolset>msvc/<toolset-msvc:version>7.1/<threading>multi - # - # due to a cross-product property combination. That may be an - # indication that build-request.expand-no-defaults is the wrong - # rule to use here. - [ feature.compress-subproperties $(raw) ] - $(defaults-to-apply) - ] ; - - if $(properties) - { - for local p in $(properties) - { - result += [ property-set.create - [ feature.expand [ feature.split $(p) ] ] ] ; - } - } - else - { - result = [ property-set.empty ] ; - } - } - else - { - result = $(property-set) ; - } - return $(result) ; -} - - -# Given a build request and requirements, return properties common to dependency -# build request and target requirements. -# -# TODO: Document exactly what 'common properties' are, whether they should -# include default property values, whether they should contain any conditional -# properties or should those be already processed, etc. See whether there are -# any differences between use cases with empty and non-empty build-request as -# well as with requirements containing and those not containing any non-free -# features. -# -rule common-properties ( build-request requirements ) -{ - # For optimization, we add free requirements directly, without using a - # complex algorithm. This gives the complex algorithm a better chance of - # caching results. - local free = [ $(requirements).free ] ; - local non-free = [ property-set.create [ $(requirements).base ] - [ $(requirements).incidental ] ] ; - - local key = .rp.$(build-request)-$(non-free) ; - if ! $($(key)) - { - $(key) = [ common-properties2 $(build-request) $(non-free) ] ; - } - result = [ $($(key)).add-raw $(free) ] ; -} - - -# Given a 'context' -- a set of already present properties, and 'requirements', -# decide which extra properties should be applied to 'context'. For conditional -# requirements, this means evaluating the condition. For indirect conditional -# requirements, this means calling a rule. Ordinary requirements are always -# applied. -# -# Handles the situation where evaluating one conditional requirement affects -# conditions of another conditional requirements, such as: -# <toolset>gcc:<variant>release <variant>release:<define>RELEASE -# -# If 'what' is 'refined' returns context refined with new requirements. If -# 'what' is 'added' returns just the requirements to be applied. -# -rule evaluate-requirements ( requirements : context : what ) -{ - # Apply non-conditional requirements. It is possible that further - # conditional requirement change a value set by non-conditional - # requirements. For example: - # - # exe a : a.cpp : <threading>single <toolset>foo:<threading>multi ; - # - # I am not sure if this should be an error, or not, especially given that - # - # <threading>single - # - # might come from project's requirements. - - local unconditional = [ feature.expand [ $(requirements).non-conditional ] ] ; - - local raw = [ $(context).raw ] ; - raw = [ property.refine $(raw) : $(unconditional) ] ; - - # We have collected properties that surely must be present in common - # properties. We now try to figure out what other properties should be added - # in order to satisfy rules (4)-(6) from the docs. - - local conditionals = [ $(requirements).conditional ] ; - # The 'count' variable has one element for each conditional feature and for - # each occurrence of '<indirect-conditional>' feature. It is used as a loop - # counter: for each iteration of the loop before we remove one element and - # the property set should stabilize before we are done. It is assumed that - # #conditionals iterations should be enough for properties to propagate - # along conditions in any direction. - local count = $(conditionals) - [ $(requirements).get <conditional> ] - and-once-more ; - - local added-requirements ; - - local current = $(raw) ; - - # It is assumed that ordinary conditional requirements can not add - # <conditional> properties (a.k.a. indirect conditional properties), and - # that rules referred to by <conditional> properties can not add new - # <conditional> properties. So the list of indirect conditionals does not - # change. - local indirect = [ $(requirements).get <conditional> ] ; - indirect = [ MATCH ^@(.*) : $(indirect) ] ; - - local ok ; - while $(count) - { - # Evaluate conditionals in context of current properties. - local e = [ property.evaluate-conditionals-in-context $(conditionals) - : $(current) ] ; - - # Evaluate indirect conditionals. - for local i in $(indirect) - { - e += [ indirect.call $(i) $(current) ] ; - } - - if $(e) = $(added-requirements) - { - # If we got the same result, we have found the final properties. - count = ; - ok = true ; - } - else - { - # Oops, conditional evaluation results have changed. Also 'current' - # contains leftovers from a previous evaluation. Recompute 'current' - # using initial properties and conditional requirements. - added-requirements = $(e) ; - current = [ property.refine $(raw) : [ feature.expand $(e) ] ] ; - } - count = $(count[2-]) ; - } - if ! $(ok) - { - errors.error "Can not evaluate conditional properties " $(conditionals) ; - } - - if $(what) = added - { - return [ property-set.create $(unconditional) $(added-requirements) ] ; - } - else if $(what) = refined - { - return [ property-set.create $(current) ] ; - } - else - { - errors.error "Invalid value of the 'what' parameter." ; - } -} - - -rule common-properties2 ( build-request requirements ) -{ - # This guarantees that default properties are present in the result, unless - # they are overriden by some requirement. FIXME: There is possibility that - # we have added <foo>bar, which is composite and expands to <foo2>bar2, but - # default value of <foo2> is not bar2, in which case it is not clear what to - # do. - # - build-request = [ $(build-request).add-defaults ] ; - # Features added by 'add-default' can be composite and expand to features - # without default values -- so they are not added yet. It could be clearer/ - # /faster to expand only newly added properties but that is not critical. - build-request = [ $(build-request).expand ] ; - - return [ evaluate-requirements $(requirements) : $(build-request) : - refined ] ; -} - -rule push-target ( target ) -{ - .targets = $(target) $(.targets) ; -} - -rule pop-target ( ) -{ - .targets = $(.targets[2-]) ; -} - -# Return the metatarget that is currently being generated. -rule current ( ) -{ - return $(.targets[1]) ; -} - - -# Implements the most standard way of constructing main target alternative from -# sources. Allows sources to be either file or other main target and handles -# generation of those dependency targets. -# -class basic-target : abstract-target -{ - import build-request ; - import build-system ; - import "class" : new ; - import errors ; - import feature ; - import property ; - import property-set ; - import sequence ; - import set ; - import targets ; - import virtual-target ; - - rule __init__ ( name : project : sources * : requirements * - : default-build * : usage-requirements * ) - { - abstract-target.__init__ $(name) : $(project) ; - - self.sources = $(sources) ; - if ! $(requirements) { - requirements = [ property-set.empty ] ; - } - self.requirements = $(requirements) ; - if ! $(default-build) - { - default-build = [ property-set.empty ] ; - } - self.default-build = $(default-build) ; - if ! $(usage-requirements) - { - usage-requirements = [ property-set.empty ] ; - } - self.usage-requirements = $(usage-requirements) ; - - if $(sources:G) - { - errors.user-error properties found in the 'sources' parameter for - [ full-name ] ; - } - } - - rule always ( ) - { - self.always = 1 ; - } - - # Returns the list of abstract-targets which are used as sources. The extra - # properties specified for sources are not represented. The only user for - # this rule at the moment is the "--dump-tests" feature of the test system. - # - rule sources ( ) - { - if ! $(self.source-targets) - { - for local s in $(self.sources) - { - self.source-targets += - [ targets.resolve-reference $(s) : $(self.project) ] ; - } - } - return $(self.source-targets) ; - } - - rule requirements ( ) - { - return $(self.requirements) ; - } - - rule default-build ( ) - { - return $(self.default-build) ; - } - - # Returns the alternative condition for this alternative, if the condition - # is satisfied by 'property-set'. - # - rule match ( property-set debug ? ) - { - # The condition is composed of all base non-conditional properties. It - # is not clear if we should expand 'self.requirements' or not. For one - # thing, it would be nice to be able to put - # <toolset>msvc-6.0 - # in requirements. On the other hand, if we have <variant>release as a - # condition it does not make sense to require <optimization>full to be - # in the build request just to select this variant. - local bcondition = [ $(self.requirements).base ] ; - local ccondition = [ $(self.requirements).conditional ] ; - local condition = [ set.difference $(bcondition) : $(ccondition) ] ; - if $(debug) - { - ECHO " next alternative: required properties:" $(condition:E=(empty)) ; - } - - if $(condition) in [ $(property-set).raw ] - { - if $(debug) - { - ECHO " matched" ; - } - return $(condition) ; - } - else - { - if $(debug) - { - ECHO " not matched" ; - } - return no-match ; - } - } - - # Takes a target reference, which might be either target id or a dependency - # property, and generates that target using 'property-set' as build request. - # - # The results are added to the variable called 'result-var'. Usage - # requirements are added to the variable called 'usage-requirements-var'. - # - rule generate-dependencies ( dependencies * : property-set - : result-var usage-requirements-var ) - { - for local dependency in $(dependencies) - { - local grist = $(dependency:G) ; - local id = $(dependency:G=) ; - - local result = [ targets.generate-from-reference $(id) : - $(self.project) : $(property-set) ] ; - - $(result-var) += $(result[2-]:G=$(grist)) ; - $(usage-requirements-var) += [ $(result[1]).raw ] ; - } - } - - # Determines final build properties, generates sources, and calls - # 'construct'. This method should not be overridden. - # - rule generate ( property-set ) - { - if [ modules.peek : .debug-building ] - { - ECHO ; - local fn = [ full-name ] ; - ECHO [ targets.indent ] "Building target '$(fn)'" ; - targets.increase-indent ; - ECHO [ targets.indent ] "Build request: " $(property-set) [ $(property-set).raw ] ; - local cf = [ build-system.command-line-free-features ] ; - ECHO [ targets.indent ] "Command line free features: " [ $(cf).raw ] ; - ECHO [ targets.indent ] "Target requirements: " [ $(self.requirements).raw ] ; - } - targets.push-target $(__name__) ; - - if ! $(self.generated.$(property-set)) - { - # Apply free features from the command line. If user said - # define=FOO - # he most likely wants this define to be set for all compiles. - property-set = [ $(property-set).refine - [ build-system.command-line-free-features ] ] ; - local rproperties = [ targets.common-properties $(property-set) - $(self.requirements) ] ; - - if [ modules.peek : .debug-building ] - { - ECHO ; - ECHO [ targets.indent ] "Common properties: " [ $(rproperties).raw ] ; - } - - if ( $(rproperties[1]) != "@error" ) && ( [ $(rproperties).get - <build> ] != no ) - { - local source-targets ; - local properties = [ $(rproperties).non-dependency ] ; - local usage-requirements ; - - generate-dependencies [ $(rproperties).dependency ] : - $(rproperties) : properties usage-requirements ; - - generate-dependencies $(self.sources) : $(rproperties) : - source-targets usage-requirements ; - - if [ modules.peek : .debug-building ] - { - ECHO ; - ECHO [ targets.indent ] "Usage requirements for" - $(self.name)": " $(usage-requirements) ; - } - - rproperties = [ property-set.create $(properties) - $(usage-requirements) ] ; - usage-requirements = [ property-set.create $(usage-requirements) ] ; - - if [ modules.peek : .debug-building ] - { - ECHO [ targets.indent ] "Build properties: " - [ $(rproperties).raw ] ; - } - - local extra = [ $(rproperties).get <source> ] ; - source-targets += $(extra:G=) ; - # We might get duplicate sources, for example if we link to two - # libraries having the same <library> usage requirement. - # Use stable sort, since for some targets the order is - # important. E.g. RUN_PY target need python source to come - # first. - source-targets = [ sequence.unique $(source-targets) : stable ] ; - - local result = [ construct $(self.name) : $(source-targets) : - $(rproperties) ] ; - - if $(result) - { - local gur = $(result[1]) ; - result = $(result[2-]) ; - - if $(self.always) - { - for local t in $(result) - { - $(t).always ; - } - } - - local s = [ create-subvariant $(result) - : [ virtual-target.recent-targets ] - : $(property-set) : $(source-targets) - : $(rproperties) : $(usage-requirements) ] ; - virtual-target.clear-recent-targets ; - - local ur = [ compute-usage-requirements $(s) ] ; - ur = [ $(ur).add $(gur) ] ; - $(s).set-usage-requirements $(ur) ; - if [ modules.peek : .debug-building ] - { - ECHO [ targets.indent ] "Usage requirements from" - $(self.name)": " [ $(ur).raw ] ; - } - - self.generated.$(property-set) = $(ur) $(result) ; - } - } - else - { - if $(rproperties[1]) = "@error" - { - ECHO [ targets.indent ] "Skipping build of:" [ full-name ] - "cannot compute common properties" ; - } - else if [ $(rproperties).get <build> ] = no - { - # If we just see <build>no, we cannot produce any reasonable - # diagnostics. The code that adds this property is expected - # to explain why a target is not built, for example using - # the configure.log-component-configuration function. - } - else - { - ECHO [ targets.indent ] "Skipping build of: " [ full-name ] - " unknown reason" ; - } - - # We are here either because there has been an error computing - # properties or there is <build>no in properties. In the latter - # case we do not want any diagnostic. In the former case, we - # need diagnostics. FIXME - - # If this target fails to build, add <build>no to properties to - # cause any parent target to fail to build. Except that it - # - does not work now, since we check for <build>no only in - # common properties, but not in properties that came from - # dependencies - # - it is not clear if that is a good idea anyway. The alias - # target, for example, should not fail to build if a - # dependency fails. - self.generated.$(property-set) = [ property-set.create <build>no ] ; - } - } - else - { - if [ modules.peek : .debug-building ] - { - ECHO [ targets.indent ] "Already built" ; - local ur = $(self.generated.$(property-set)) ; - ur = $(ur[0]) ; - targets.increase-indent ; - ECHO [ targets.indent ] "Usage requirements from" - $(self.name)": " [ $(ur).raw ] ; - targets.decrease-indent ; - } - } - - targets.pop-target ; - targets.decrease-indent ; - return $(self.generated.$(property-set)) ; - } - - # Given the set of generated targets, and refined build properties, - # determines and sets appropriate usage requirements on those targets. - # - rule compute-usage-requirements ( subvariant ) - { - local rproperties = [ $(subvariant).build-properties ] ; - xusage-requirements = [ targets.evaluate-requirements - $(self.usage-requirements) : $(rproperties) : added ] ; - - # We generate all dependency properties and add them, as well as their - # usage requirements, to the result. - local extra ; - generate-dependencies [ $(xusage-requirements).dependency ] : - $(rproperties) : extra extra ; - - local result = [ property-set.create - [ $(xusage-requirements).non-dependency ] $(extra) ] ; - - # Propagate usage requirements we got from sources, except for the - # <pch-header> and <pch-file> features. - # - # That feature specifies which pch file to use, and should apply only to - # direct dependents. Consider: - # - # pch pch1 : ... - # lib lib1 : ..... pch1 ; - # pch pch2 : - # lib lib2 : pch2 lib1 ; - # - # Here, lib2 should not get <pch-header> property from pch1. - # - # Essentially, when those two features are in usage requirements, they - # are propagated only to direct dependents. We might need a more general - # mechanism, but for now, only those two features are special. - # - # TODO - Actually there are more possible candidates like for instance - # when listing static library X as a source for another static library. - # Then static library X will be added as a <source> property to the - # second library's usage requirements but those requirements should last - # only up to the first executable or shared library that actually links - # to it. - local raw = [ $(subvariant).sources-usage-requirements ] ; - raw = [ $(raw).raw ] ; - raw = [ property.change $(raw) : <pch-header> ] ; - raw = [ property.change $(raw) : <pch-file> ] ; - return [ $(result).add [ property-set.create $(raw) ] ] ; - } - - # Creates new subvariant instances for 'targets'. - # 'root-targets' - virtual targets to be returned to dependants - # 'all-targets' - virtual targets created while building this main target - # 'build-request' - property-set instance with requested build properties - # - local rule create-subvariant ( root-targets * : all-targets * : - build-request : sources * : rproperties : usage-requirements ) - { - for local e in $(root-targets) - { - $(e).root true ; - } - - # Process all virtual targets that will be created if this main target - # is created. - local s = [ new subvariant $(__name__) : $(build-request) : $(sources) : - $(rproperties) : $(usage-requirements) : $(all-targets) ] ; - for local v in $(all-targets) - { - if ! [ $(v).creating-subvariant ] - { - $(v).creating-subvariant $(s) ; - } - } - return $(s) ; - } - - # Constructs virtual targets for this abstract target and the dependency - # graph. Returns a usage-requirements property-set and a list of virtual - # targets. Should be overriden in derived classes. - # - rule construct ( name : source-targets * : properties * ) - { - errors.error "method should be defined in derived classes" ; - } -} - - -class typed-target : basic-target -{ - import generators ; - - rule __init__ ( name : project : type : sources * : requirements * : - default-build * : usage-requirements * ) - { - basic-target.__init__ $(name) : $(project) : $(sources) : - $(requirements) : $(default-build) : $(usage-requirements) ; - - self.type = $(type) ; - } - - rule type ( ) - { - return $(self.type) ; - } - - rule construct ( name : source-targets * : property-set ) - { - local r = [ generators.construct $(self.project) $(name:S=) : $(self.type) - : [ property-set.create [ $(property-set).raw ] - <main-target-type>$(self.type) ] - : $(source-targets) : true ] ; - if ! $(r) - { - ECHO "warn: Unable to construct" [ full-name ] ; - - # Are there any top-level generators for this type/property set. - if ! [ generators.find-viable-generators $(self.type) - : $(property-set) ] - { - ECHO "error: no generators were found for type '$(self.type)'" ; - ECHO "error: and the requested properties" ; - ECHO "error: make sure you've configured the needed tools" ; - ECHO "See http://boost.org/boost-build2/doc/html/bbv2/advanced/configuration.html" ; - ECHO "To debug this problem, try the --debug-generators option." ; - EXIT ; - } - } - return $(r) ; - } -} - - -# Return the list of sources to use, if main target rule is invoked with -# 'sources'. If there are any objects in 'sources', they are treated as main -# target instances, and the name of such targets are adjusted to be -# '<name_of_this_target>__<name_of_source_target>'. Such renaming is disabled if -# a non-empty value is passed as the 'no-renaming' parameter. -# -rule main-target-sources ( sources * : main-target-name : no-renaming ? ) -{ - local result ; - for local t in $(sources) - { - if [ class.is-instance $(t) ] - { - local name = [ $(t).name ] ; - if ! $(no-renaming) - { - name = $(main-target-name)__$(name) ; - $(t).rename $(name) ; - } - # Inline targets are not built by default. - local p = [ $(t).project ] ; - $(p).mark-target-as-explicit $(name) ; - result += $(name) ; - } - else - { - result += $(t) ; - } - } - return $(result) ; -} - - -# Returns the requirements to use when declaring a main target, obtained by -# translating all specified property paths and refining project requirements -# with the ones specified for the target. -# -rule main-target-requirements ( - specification * # Properties explicitly specified for the main target. - : project # Project where the main target is to be declared. -) -{ - specification += [ toolset.requirements ] ; - - local requirements = [ property-set.refine-from-user-input - [ $(project).get requirements ] : $(specification) : - [ $(project).project-module ] : [ $(project).get location ] ] ; - if $(requirements[1]) = "@error" - { - errors.error "Conflicting requirements for target:" $(requirements) ; - } - return $(requirements) ; -} - - -# Returns the usage requirements to use when declaring a main target, which are -# obtained by translating all specified property paths and adding project's -# usage requirements. -# -rule main-target-usage-requirements ( - specification * # Use-properties explicitly specified for a main target. - : project # Project where the main target is to be declared. -) -{ - local project-usage-requirements = [ $(project).get usage-requirements ] ; - - # We do not use 'refine-from-user-input' because: - # - I am not sure if removing parent's usage requirements makes sense - # - refining usage requirements is not needed, since usage requirements are - # always free. - local usage-requirements = [ property-set.create-from-user-input - $(specification) - : [ $(project).project-module ] [ $(project).get location ] ] ; - - return [ $(project-usage-requirements).add $(usage-requirements) ] ; -} - - -# Return the default build value to use when declaring a main target, which is -# obtained by using the specified value if not empty and parent's default build -# attribute otherwise. -# -rule main-target-default-build ( - specification * # Default build explicitly specified for a main target. - : project # Project where the main target is to be declared. -) -{ - local result ; - if $(specification) - { - result = $(specification) ; - } - else - { - result = [ $(project).get default-build ] ; - } - return [ property-set.create-with-validation $(result) ] ; -} - - -# Registers the specified target as a main target alternative and returns it. -# -rule main-target-alternative ( target ) -{ - local ptarget = [ $(target).project ] ; - $(ptarget).add-alternative $(target) ; - return $(target) ; -} - -# Creates a new metargets with the specified properties, using 'klass' as -# the class. The 'name', 'sources', -# 'requirements', 'default-build' and 'usage-requirements' are assumed to be in -# the form specified by the user in Jamfile corresponding to 'project'. -# -rule create-metatarget ( klass : project : name : sources * : requirements * : - default-build * : usage-requirements * ) -{ - return [ - targets.main-target-alternative - [ new $(klass) $(name) : $(project) - : [ targets.main-target-sources $(sources) : $(name) ] - : [ targets.main-target-requirements $(requirements) : $(project) ] - : [ targets.main-target-default-build $(default-build) : $(project) ] - : [ targets.main-target-usage-requirements $(usage-requirements) : $(project) ] - ] ] ; -} - -# Creates a typed-target with the specified properties. The 'name', 'sources', -# 'requirements', 'default-build' and 'usage-requirements' are assumed to be in -# the form specified by the user in Jamfile corresponding to 'project'. -# -rule create-typed-target ( type : project : name : sources * : requirements * : - default-build * : usage-requirements * ) -{ - return [ - targets.main-target-alternative - [ new typed-target $(name) : $(project) : $(type) - : [ targets.main-target-sources $(sources) : $(name) ] - : [ targets.main-target-requirements $(requirements) : $(project) ] - : [ targets.main-target-default-build $(default-build) : $(project) ] - : [ targets.main-target-usage-requirements $(usage-requirements) : $(project) ] - ] ] ; -} diff --git a/jam-files/boost-build/build/targets.py b/jam-files/boost-build/build/targets.py deleted file mode 100644 index a35612ce..00000000 --- a/jam-files/boost-build/build/targets.py +++ /dev/null @@ -1,1401 +0,0 @@ -# Status: ported. -# Base revision: 64488 - -# Copyright Vladimir Prus 2002-2007. -# Copyright Rene Rivera 2006. -# -# Distributed under the Boost Software License, Version 1.0. -# (See accompanying file LICENSE_1_0.txt or copy at -# http://www.boost.org/LICENSE_1_0.txt) - -# Supports 'abstract' targets, which are targets explicitly defined in Jamfile. -# -# Abstract targets are represented by classes derived from 'AbstractTarget' class. -# The first abstract target is 'project_target', which is created for each -# Jamfile, and can be obtained by the 'target' rule in the Jamfile's module. -# (see project.jam). -# -# Project targets keep a list of 'MainTarget' instances. -# A main target is what the user explicitly defines in a Jamfile. It is -# possible to have several definitions for a main target, for example to have -# different lists of sources for different platforms. So, main targets -# keep a list of alternatives. -# -# Each alternative is an instance of 'AbstractTarget'. When a main target -# subvariant is defined by some rule, that rule will decide what class to -# use, create an instance of that class and add it to the list of alternatives -# for the main target. -# -# Rules supplied by the build system will use only targets derived -# from 'BasicTarget' class, which will provide some default behaviour. -# There will be two classes derived from it, 'make-target', created by the -# 'make' rule, and 'TypedTarget', created by rules such as 'exe' and 'dll'. - -# -# +------------------------+ -# |AbstractTarget | -# +========================+ -# |name | -# |project | -# | | -# |generate(properties) = 0| -# +-----------+------------+ -# | -# ^ -# / \ -# +-+-+ -# | -# | -# +------------------------+------+------------------------------+ -# | | | -# | | | -# +----------+-----------+ +------+------+ +------+-------+ -# | project_target | | MainTarget | | BasicTarget | -# +======================+ 1 * +=============+ alternatives +==============+ -# | generate(properties) |o-----------+ generate |<>------------->| generate | -# | main-target | +-------------+ | construct = 0| -# +----------------------+ +--------------+ -# | -# ^ -# / \ -# +-+-+ -# | -# | -# ...--+----------------+------------------+----------------+---+ -# | | | | -# | | | | -# ... ---+-----+ +------+-------+ +------+------+ +--------+-----+ -# | | TypedTarget | | make-target | | stage-target | -# . +==============+ +=============+ +==============+ -# . | construct | | construct | | construct | -# +--------------+ +-------------+ +--------------+ - -import re -import os.path -import sys - -from b2.manager import get_manager - -from b2.util.utility import * -import property, project, virtual_target, property_set, feature, generators, toolset -from virtual_target import Subvariant -from b2.exceptions import * -from b2.util.sequence import unique -from b2.util import path, bjam_signature -from b2.build.errors import user_error_checkpoint - -import b2.build.build_request as build_request - -import b2.util.set -_re_separate_target_from_properties = re.compile (r'^([^<]*)(/(<.*))?$') - -class TargetRegistry: - - def __init__ (self): - # All targets that are currently being built. - # Only the key is id (target), the value is the actual object. - self.targets_being_built_ = {} - - # Current indent for debugging messages - self.indent_ = "" - - self.debug_building_ = "--debug-building" in bjam.variable("ARGV") - - self.targets_ = [] - - def main_target_alternative (self, target): - """ Registers the specified target as a main target alternatives. - Returns 'target'. - """ - target.project ().add_alternative (target) - return target - - def main_target_sources (self, sources, main_target_name, no_renaming=0): - """Return the list of sources to use, if main target rule is invoked - with 'sources'. If there are any objects in 'sources', they are treated - as main target instances, and the name of such targets are adjusted to - be '<name_of_this_target>__<name_of_source_target>'. Such renaming - is disabled is non-empty value is passed for 'no-renaming' parameter.""" - result = [] - - for t in sources: - - t = b2.util.jam_to_value_maybe(t) - - if isinstance (t, AbstractTarget): - name = t.name () - - if not no_renaming: - name = main_target_name + '__' + name - t.rename (name) - - # Inline targets are not built by default. - p = t.project() - p.mark_targets_as_explicit([name]) - result.append(name) - - else: - result.append (t) - - return result - - - def main_target_requirements(self, specification, project): - """Returns the requirement to use when declaring a main target, - which are obtained by - - translating all specified property paths, and - - refining project requirements with the one specified for the target - - 'specification' are the properties xplicitly specified for a - main target - 'project' is the project where the main taret is to be declared.""" - - specification.extend(toolset.requirements()) - - requirements = property_set.refine_from_user_input( - project.get("requirements"), specification, - project.project_module(), project.get("location")) - - return requirements - - def main_target_usage_requirements (self, specification, project): - """ Returns the use requirement to use when declaraing a main target, - which are obtained by - - translating all specified property paths, and - - adding project's usage requirements - specification: Use-properties explicitly specified for a main target - project: Project where the main target is to be declared - """ - project_usage_requirements = project.get ('usage-requirements') - - # We don't use 'refine-from-user-input' because I'm not sure if: - # - removing of parent's usage requirements makes sense - # - refining of usage requirements is not needed, since usage requirements - # are always free. - usage_requirements = property_set.create_from_user_input( - specification, project.project_module(), project.get("location")) - - return project_usage_requirements.add (usage_requirements) - - def main_target_default_build (self, specification, project): - """ Return the default build value to use when declaring a main target, - which is obtained by using specified value if not empty and parent's - default build attribute otherwise. - specification: Default build explicitly specified for a main target - project: Project where the main target is to be declared - """ - if specification: - return property_set.create_with_validation(specification) - else: - return project.get ('default-build') - - def start_building (self, main_target_instance): - """ Helper rules to detect cycles in main target references. - """ - if self.targets_being_built_.has_key(id(main_target_instance)): - names = [] - for t in self.targets_being_built_.values() + [main_target_instance]: - names.append (t.full_name()) - - get_manager().errors()("Recursion in main target references\n") - - self.targets_being_built_[id(main_target_instance)] = main_target_instance - - def end_building (self, main_target_instance): - assert (self.targets_being_built_.has_key (id (main_target_instance))) - del self.targets_being_built_ [id (main_target_instance)] - - def create_typed_target (self, type, project, name, sources, requirements, default_build, usage_requirements): - """ Creates a TypedTarget with the specified properties. - The 'name', 'sources', 'requirements', 'default_build' and - 'usage_requirements' are assumed to be in the form specified - by the user in Jamfile corresponding to 'project'. - """ - return self.main_target_alternative (TypedTarget (name, project, type, - self.main_target_sources (sources, name), - self.main_target_requirements (requirements, project), - self.main_target_default_build (default_build, project), - self.main_target_usage_requirements (usage_requirements, project))) - - def increase_indent(self): - self.indent_ += " " - - def decrease_indent(self): - self.indent_ = self.indent_[0:-4] - - def logging(self): - return self.debug_building_ - - def log(self, message): - if self.debug_building_: - print self.indent_ + message - - def push_target(self, target): - self.targets_.append(target) - - def pop_target(self): - self.targets_ = self.targets_[:-1] - - def current(self): - return self.targets_[0] - - -class GenerateResult: - - def __init__ (self, ur=None, targets=None): - if not targets: - targets = [] - - self.__usage_requirements = ur - self.__targets = targets - assert all(isinstance(t, virtual_target.VirtualTarget) for t in targets) - - if not self.__usage_requirements: - self.__usage_requirements = property_set.empty () - - def usage_requirements (self): - return self.__usage_requirements - - def targets (self): - return self.__targets - - def extend (self, other): - assert (isinstance (other, GenerateResult)) - - self.__usage_requirements = self.__usage_requirements.add (other.usage_requirements ()) - self.__targets.extend (other.targets ()) - -class AbstractTarget: - """ Base class for all abstract targets. - """ - def __init__ (self, name, project, manager = None): - """ manager: the Manager object - name: name of the target - project: the project target to which this one belongs - manager:the manager object. If none, uses project.manager () - """ - assert (isinstance (project, ProjectTarget)) - # Note: it might seem that we don't need either name or project at all. - # However, there are places where we really need it. One example is error - # messages which should name problematic targets. Another is setting correct - # paths for sources and generated files. - - # Why allow manager to be specified? Because otherwise project target could not derive - # from this class. - if manager: - self.manager_ = manager - else: - self.manager_ = project.manager () - - self.name_ = name - self.project_ = project - - def manager (self): - return self.manager_ - - def name (self): - """ Returns the name of this target. - """ - return self.name_ - - def project (self): - """ Returns the project for this target. - """ - return self.project_ - - def location (self): - """ Return the location where the target was declared. - """ - return self.location_ - - def full_name (self): - """ Returns a user-readable name for this target. - """ - location = self.project ().get ('location') - return location + '/' + self.name_ - - def generate (self, property_set): - """ Takes a property set. Generates virtual targets for this abstract - target, using the specified properties, unless a different value of some - feature is required by the target. - On success, returns a GenerateResult instance with: - - a property_set with the usage requirements to be - applied to dependents - - a list of produced virtual targets, which may be - empty. - If 'property_set' is empty, performs default build of this - target, in a way specific to derived class. - """ - raise BaseException ("method should be defined in derived classes") - - def rename (self, new_name): - self.name_ = new_name - -class ProjectTarget (AbstractTarget): - """ Project target class (derived from 'AbstractTarget') - - This class these responsibilities: - - maintaining a list of main target in this project and - building it - - Main targets are constructed in two stages: - - When Jamfile is read, a number of calls to 'add_alternative' is made. - At that time, alternatives can also be renamed to account for inline - targets. - - The first time 'main-target' or 'has-main-target' rule is called, - all alternatives are enumerated an main targets are created. - """ - def __init__ (self, manager, name, project_module, parent_project, requirements, default_build): - AbstractTarget.__init__ (self, name, self, manager) - - self.project_module_ = project_module - self.location_ = manager.projects().attribute (project_module, 'location') - self.requirements_ = requirements - self.default_build_ = default_build - - self.build_dir_ = None - - # A cache of IDs - self.ids_cache_ = {} - - # True is main targets have already been built. - self.built_main_targets_ = False - - # A list of the registered alternatives for this project. - self.alternatives_ = [] - - # A map from main target name to the target corresponding - # to it. - self.main_target_ = {} - - # Targets marked as explicit. - self.explicit_targets_ = set() - - # Targets marked as always - self.always_targets_ = set() - - # The constants defined for this project. - self.constants_ = {} - - # Whether targets for all main target are already created. - self.built_main_targets_ = 0 - - if parent_project: - self.inherit (parent_project) - - - # TODO: This is needed only by the 'make' rule. Need to find the - # way to make 'make' work without this method. - def project_module (self): - return self.project_module_ - - def get (self, attribute): - return self.manager().projects().attribute( - self.project_module_, attribute) - - def build_dir (self): - if not self.build_dir_: - self.build_dir_ = self.get ('build-dir') - if not self.build_dir_: - self.build_dir_ = os.path.join(self.project_.get ('location'), 'bin') - - return self.build_dir_ - - def generate (self, ps): - """ Generates all possible targets contained in this project. - """ - self.manager_.targets().log( - "Building project '%s' with '%s'" % (self.name (), str(ps))) - self.manager_.targets().increase_indent () - - result = GenerateResult () - - for t in self.targets_to_build (): - g = t.generate (ps) - result.extend (g) - - self.manager_.targets().decrease_indent () - return result - - def targets_to_build (self): - """ Computes and returns a list of AbstractTarget instances which - must be built when this project is built. - """ - result = [] - - if not self.built_main_targets_: - self.build_main_targets () - - # Collect all main targets here, except for "explicit" ones. - for n, t in self.main_target_.iteritems (): - if not t.name () in self.explicit_targets_: - result.append (t) - - # Collect all projects referenced via "projects-to-build" attribute. - self_location = self.get ('location') - for pn in self.get ('projects-to-build'): - result.append (self.find(pn + "/")) - - return result - - def mark_targets_as_explicit (self, target_names): - """Add 'target' to the list of targets in this project - that should be build only by explicit request.""" - - # Record the name of the target, not instance, since this - # rule is called before main target instaces are created. - self.explicit_targets_.update(target_names) - - def mark_targets_as_always(self, target_names): - self.always_targets_.update(target_names) - - def add_alternative (self, target_instance): - """ Add new target alternative. - """ - if self.built_main_targets_: - raise IllegalOperation ("add-alternative called when main targets are already created for project '%s'" % self.full_name ()) - - self.alternatives_.append (target_instance) - - def main_target (self, name): - if not self.built_main_targets_: - self.build_main_targets() - - return self.main_target_[name] - - def has_main_target (self, name): - """Tells if a main target with the specified name exists.""" - if not self.built_main_targets_: - self.build_main_targets() - - return self.main_target_.has_key(name) - - def create_main_target (self, name): - """ Returns a 'MainTarget' class instance corresponding to the 'name'. - """ - if not self.built_main_targets_: - self.build_main_targets () - - return self.main_targets_.get (name, None) - - - def find_really(self, id): - """ Find and return the target with the specified id, treated - relative to self. - """ - result = None - current_location = self.get ('location') - - __re_split_project_target = re.compile (r'(.*)//(.*)') - split = __re_split_project_target.match (id) - - project_part = None - target_part = None - - if split: - project_part = split.group (1) - target_part = split.group (2) - - project_registry = self.project_.manager ().projects () - - extra_error_message = '' - if project_part: - # There's explicit project part in id. Looks up the - # project and pass the request to it. - pm = project_registry.find (project_part, current_location) - - if pm: - project_target = project_registry.target (pm) - result = project_target.find (target_part, no_error=1) - - else: - extra_error_message = "error: could not find project '$(project_part)'" - - else: - # Interpret target-name as name of main target - # Need to do this before checking for file. Consider this: - # - # exe test : test.cpp ; - # install s : test : <location>. ; - # - # After first build we'll have target 'test' in Jamfile and file - # 'test' on the disk. We need target to override the file. - - result = None - if self.has_main_target(id): - result = self.main_target(id) - - if not result: - result = FileReference (self.manager_, id, self.project_) - if not result.exists (): - # File actually does not exist. - # Reset 'target' so that an error is issued. - result = None - - - if not result: - # Interpret id as project-id - project_module = project_registry.find (id, current_location) - if project_module: - result = project_registry.target (project_module) - - return result - - def find (self, id, no_error = False): - v = self.ids_cache_.get (id, None) - - if not v: - v = self.find_really (id) - self.ids_cache_ [id] = v - - if v or no_error: - return v - - raise BaseException ("Unable to find file or target named '%s'\nreferred from project at '%s'" % (id, self.get ('location'))) - - - def build_main_targets (self): - self.built_main_targets_ = True - - for a in self.alternatives_: - name = a.name () - if not self.main_target_.has_key (name): - t = MainTarget (name, self.project_) - self.main_target_ [name] = t - - if name in self.always_targets_: - a.always() - - self.main_target_ [name].add_alternative (a) - - def add_constant(self, name, value, path=0): - """Adds a new constant for this project. - - The constant will be available for use in Jamfile - module for this project. If 'path' is true, - the constant will be interpreted relatively - to the location of project. - """ - - if path: - l = self.location_ - if not l: - # Project corresponding to config files do not have - # 'location' attribute, but do have source location. - # It might be more reasonable to make every project have - # a location and use some other approach to prevent buildable - # targets in config files, but that's for later. - l = get('source-location') - - value = os.path.join(l, value) - # Now make the value absolute path - value = os.path.join(os.getcwd(), value) - - self.constants_[name] = value - bjam.call("set-variable", self.project_module(), name, value) - - def inherit(self, parent_project): - for c in parent_project.constants_: - # No need to pass the type. Path constants were converted to - # absolute paths already by parent. - self.add_constant(c, parent_project.constants_[c]) - - # Import rules from parent - this_module = self.project_module() - parent_module = parent_project.project_module() - - rules = bjam.call("RULENAMES", parent_module) - if not rules: - rules = [] - user_rules = [x for x in rules - if x not in self.manager().projects().project_rules().all_names()] - if user_rules: - bjam.call("import-rules-from-parent", parent_module, this_module, user_rules) - -class MainTarget (AbstractTarget): - """ A named top-level target in Jamfile. - """ - def __init__ (self, name, project): - AbstractTarget.__init__ (self, name, project) - self.alternatives_ = [] - self.default_build_ = property_set.empty () - - def add_alternative (self, target): - """ Add a new alternative for this target. - """ - d = target.default_build () - - if self.alternatives_ and self.default_build_ != d: - get_manager().errors()("default build must be identical in all alternatives\n" - "main target is '%s'\n" - "with '%s'\n" - "differing from previous default build: '%s'" % (self.full_name (), d.raw (), self.default_build_.raw ())) - - else: - self.default_build_ = d - - self.alternatives_.append (target) - - def __select_alternatives (self, property_set, debug): - """ Returns the best viable alternative for this property_set - See the documentation for selection rules. - # TODO: shouldn't this be 'alternative' (singular)? - """ - # When selecting alternatives we have to consider defaults, - # for example: - # lib l : l.cpp : <variant>debug ; - # lib l : l_opt.cpp : <variant>release ; - # won't work unless we add default value <variant>debug. - property_set = property_set.add_defaults () - - # The algorithm: we keep the current best viable alternative. - # When we've got new best viable alternative, we compare it - # with the current one. - best = None - best_properties = None - - if len (self.alternatives_) == 0: - return None - - if len (self.alternatives_) == 1: - return self.alternatives_ [0] - - if debug: - print "Property set for selection:", property_set - - for v in self.alternatives_: - properties = v.match (property_set, debug) - - if properties is not None: - if not best: - best = v - best_properties = properties - - else: - if b2.util.set.equal (properties, best_properties): - return None - - elif b2.util.set.contains (properties, best_properties): - # Do nothing, this alternative is worse - pass - - elif b2.util.set.contains (best_properties, properties): - best = v - best_properties = properties - - else: - return None - - return best - - def apply_default_build (self, property_set): - return apply_default_build(property_set, self.default_build_) - - def generate (self, ps): - """ Select an alternative for this main target, by finding all alternatives - which requirements are satisfied by 'properties' and picking the one with - longest requirements set. - Returns the result of calling 'generate' on that alternative. - """ - self.manager_.targets ().start_building (self) - - # We want composite properties in build request act as if - # all the properties it expands too are explicitly specified. - ps = ps.expand () - - all_property_sets = self.apply_default_build (ps) - - result = GenerateResult () - - for p in all_property_sets: - result.extend (self.__generate_really (p)) - - self.manager_.targets ().end_building (self) - - return result - - def __generate_really (self, prop_set): - """ Generates the main target with the given property set - and returns a list which first element is property_set object - containing usage_requirements of generated target and with - generated virtual target in other elements. It's possible - that no targets are generated. - """ - best_alternative = self.__select_alternatives (prop_set, debug=0) - - if not best_alternative: - # FIXME: revive. - # self.__select_alternatives(prop_set, debug=1) - self.manager_.errors()( - "No best alternative for '%s'.\n" - % (self.full_name(),)) - - result = best_alternative.generate (prop_set) - - # Now return virtual targets for the only alternative - return result - - def rename(self, new_name): - AbstractTarget.rename(self, new_name) - for a in self.alternatives_: - a.rename(new_name) - -class FileReference (AbstractTarget): - """ Abstract target which refers to a source file. - This is artificial creature; it's usefull so that sources to - a target can be represented as list of abstract target instances. - """ - def __init__ (self, manager, file, project): - AbstractTarget.__init__ (self, file, project) - self.file_location_ = None - - def generate (self, properties): - return GenerateResult (None, [ - self.manager_.virtual_targets ().from_file ( - self.name_, self.location(), self.project_) ]) - - def exists (self): - """ Returns true if the referred file really exists. - """ - if self.location (): - return True - else: - return False - - def location (self): - # Returns the location of target. Needed by 'testing.jam' - if not self.file_location_: - source_location = self.project_.get('source-location') - - for src_dir in source_location: - location = os.path.join(src_dir, self.name()) - if os.path.isfile(location): - self.file_location_ = src_dir - self.file_path = location - break - - return self.file_location_ - -def resolve_reference(target_reference, project): - """ Given a target_reference, made in context of 'project', - returns the AbstractTarget instance that is referred to, as well - as properties explicitly specified for this reference. - """ - # Separate target name from properties override - split = _re_separate_target_from_properties.match (target_reference) - if not split: - raise BaseException ("Invalid reference: '%s'" % target_reference) - - id = split.group (1) - - sproperties = [] - - if split.group (3): - sproperties = property.create_from_strings(feature.split(split.group(3))) - sproperties = feature.expand_composites(sproperties) - - # Find the target - target = project.find (id) - - return (target, property_set.create(sproperties)) - -def generate_from_reference(target_reference, project, property_set): - """ Attempts to generate the target given by target reference, which - can refer both to a main target or to a file. - Returns a list consisting of - - usage requirements - - generated virtual targets, if any - target_reference: Target reference - project: Project where the reference is made - property_set: Properties of the main target that makes the reference - """ - target, sproperties = resolve_reference(target_reference, project) - - # Take properties which should be propagated and refine them - # with source-specific requirements. - propagated = property_set.propagated() - rproperties = propagated.refine(sproperties) - - return target.generate(rproperties) - - - -class BasicTarget (AbstractTarget): - """ Implements the most standard way of constructing main target - alternative from sources. Allows sources to be either file or - other main target and handles generation of those dependency - targets. - """ - def __init__ (self, name, project, sources, requirements = None, default_build = None, usage_requirements = None): - AbstractTarget.__init__ (self, name, project) - - for s in sources: - if get_grist (s): - raise InvalidSource ("property '%s' found in the 'sources' parameter for '%s'" % (s, name)) - - self.sources_ = sources - - if not requirements: requirements = property_set.empty () - self.requirements_ = requirements - - if not default_build: default_build = property_set.empty () - self.default_build_ = default_build - - if not usage_requirements: usage_requirements = property_set.empty () - self.usage_requirements_ = usage_requirements - - # A cache for resolved references - self.source_targets_ = None - - # A cache for generated targets - self.generated_ = {} - - # A cache for build requests - self.request_cache = {} - - # Result of 'capture_user_context' has everything. For example, if this - # target is declare as result of loading Jamfile which was loaded when - # building target B which was requested from A, then we'll have A, B and - # Jamroot location in context. We only care about Jamroot location, most - # of the times. - self.user_context_ = self.manager_.errors().capture_user_context()[-1:] - - self.always_ = False - - def always(self): - self.always_ = True - - def sources (self): - """ Returns the list of AbstractTargets which are used as sources. - The extra properties specified for sources are not represented. - The only used of this rule at the moment is the '--dump-tests' - feature of the test system. - """ - if self.source_targets_ == None: - self.source_targets_ = [] - for s in self.sources_: - self.source_targets_.append(resolve_reference(s, self.project_)[0]) - - return self.source_targets_ - - def requirements (self): - return self.requirements_ - - def default_build (self): - return self.default_build_ - - def common_properties (self, build_request, requirements): - """ Given build request and requirements, return properties - common to dependency build request and target build - properties. - """ - # For optimization, we add free unconditional requirements directly, - # without using complex algorithsm. - # This gives the complex algorithm better chance of caching results. - # The exact effect of this "optimization" is no longer clear - free_unconditional = [] - other = [] - for p in requirements.all(): - if p.feature().free() and not p.condition() and p.feature().name() != 'conditional': - free_unconditional.append(p) - else: - other.append(p) - other = property_set.create(other) - - key = (build_request, other) - if not self.request_cache.has_key(key): - self.request_cache[key] = self.__common_properties2 (build_request, other) - - return self.request_cache[key].add_raw(free_unconditional) - - # Given 'context' -- a set of already present properties, and 'requirements', - # decide which extra properties should be applied to 'context'. - # For conditional requirements, this means evaluating condition. For - # indirect conditional requirements, this means calling a rule. Ordinary - # requirements are always applied. - # - # Handles situation where evaluating one conditional requirements affects - # condition of another conditional requirements, for example: - # - # <toolset>gcc:<variant>release <variant>release:<define>RELEASE - # - # If 'what' is 'refined' returns context refined with new requirements. - # If 'what' is 'added' returns just the requirements that must be applied. - def evaluate_requirements(self, requirements, context, what): - # Apply non-conditional requirements. - # It's possible that that further conditional requirement change - # a value set by non-conditional requirements. For example: - # - # exe a : a.cpp : <threading>single <toolset>foo:<threading>multi ; - # - # I'm not sure if this should be an error, or not, especially given that - # - # <threading>single - # - # might come from project's requirements. - unconditional = feature.expand(requirements.non_conditional()) - - context = context.refine(property_set.create(unconditional)) - - # We've collected properties that surely must be present in common - # properties. We now try to figure out what other properties - # should be added in order to satisfy rules (4)-(6) from the docs. - - conditionals = property_set.create(requirements.conditional()) - - # It's supposed that #conditionals iterations - # should be enough for properties to propagate along conditions in any - # direction. - max_iterations = len(conditionals.all()) +\ - len(requirements.get("<conditional>")) + 1 - - added_requirements = [] - current = context - - # It's assumed that ordinary conditional requirements can't add - # <indirect-conditional> properties, and that rules referred - # by <indirect-conditional> properties can't add new - # <indirect-conditional> properties. So the list of indirect conditionals - # does not change. - indirect = requirements.get("<conditional>") - - ok = 0 - for i in range(0, max_iterations): - - e = conditionals.evaluate_conditionals(current).all()[:] - - # Evaluate indirect conditionals. - for i in indirect: - i = b2.util.jam_to_value_maybe(i) - if callable(i): - # This is Python callable, yeah. - e.extend(i(current)) - else: - # Name of bjam function. Because bjam is unable to handle - # list of Property, pass list of strings. - br = b2.util.call_jam_function(i[1:], [str(p) for p in current.all()]) - if br: - e.extend(property.create_from_strings(br)) - - if e == added_requirements: - # If we got the same result, we've found final properties. - ok = 1 - break - else: - # Oops, results of evaluation of conditionals has changed. - # Also 'current' contains leftover from previous evaluation. - # Recompute 'current' using initial properties and conditional - # requirements. - added_requirements = e - current = context.refine(property_set.create(feature.expand(e))) - - if not ok: - self.manager().errors()("Can't evaluate conditional properties " - + str(conditionals)) - - - if what == "added": - return property_set.create(unconditional + added_requirements) - elif what == "refined": - return current - else: - self.manager().errors("Invalid value of the 'what' parameter") - - def __common_properties2(self, build_request, requirements): - # This guarantees that default properties are present - # in result, unless they are overrided by some requirement. - # TODO: There is possibility that we've added <foo>bar, which is composite - # and expands to <foo2>bar2, but default value of <foo2> is not bar2, - # in which case it's not clear what to do. - # - build_request = build_request.add_defaults() - # Featured added by 'add-default' can be composite and expand - # to features without default values -- so they are not added yet. - # It could be clearer/faster to expand only newly added properties - # but that's not critical. - build_request = build_request.expand() - - return self.evaluate_requirements(requirements, build_request, - "refined") - - def match (self, property_set, debug): - """ Returns the alternative condition for this alternative, if - the condition is satisfied by 'property_set'. - """ - # The condition is composed of all base non-conditional properties. - # It's not clear if we should expand 'self.requirements_' or not. - # For one thing, it would be nice to be able to put - # <toolset>msvc-6.0 - # in requirements. - # On the other hand, if we have <variant>release in condition it - # does not make sense to require <optimization>full to be in - # build request just to select this variant. - bcondition = self.requirements_.base () - ccondition = self.requirements_.conditional () - condition = b2.util.set.difference (bcondition, ccondition) - - if debug: - print " next alternative: required properties:", [str(p) for p in condition] - - if b2.util.set.contains (condition, property_set.all()): - - if debug: - print " matched" - - return condition - - else: - return None - - - def generate_dependency_targets (self, target_ids, property_set): - targets = [] - usage_requirements = [] - for id in target_ids: - - result = generate_from_reference(id, self.project_, property_set) - targets += result.targets() - usage_requirements += result.usage_requirements().all() - - return (targets, usage_requirements) - - def generate_dependency_properties(self, properties, ps): - """ Takes a target reference, which might be either target id - or a dependency property, and generates that target using - 'property_set' as build request. - - Returns a tuple (result, usage_requirements). - """ - result_properties = [] - usage_requirements = [] - for p in properties: - - result = generate_from_reference(p.value(), self.project_, ps) - - for t in result.targets(): - result_properties.append(property.Property(p.feature(), t)) - - usage_requirements += result.usage_requirements().all() - - return (result_properties, usage_requirements) - - - - - @user_error_checkpoint - def generate (self, ps): - """ Determines final build properties, generates sources, - and calls 'construct'. This method should not be - overridden. - """ - self.manager_.errors().push_user_context( - "Generating target " + self.full_name(), self.user_context_) - - if self.manager().targets().logging(): - self.manager().targets().log( - "Building target '%s'" % self.name_) - self.manager().targets().increase_indent () - self.manager().targets().log( - "Build request: '%s'" % str (ps.raw ())) - cf = self.manager().command_line_free_features() - self.manager().targets().log( - "Command line free features: '%s'" % str (cf.raw ())) - self.manager().targets().log( - "Target requirements: %s'" % str (self.requirements().raw ())) - - self.manager().targets().push_target(self) - - if not self.generated_.has_key(ps): - - # Apply free features form the command line. If user - # said - # define=FOO - # he most likely want this define to be set for all compiles. - ps = ps.refine(self.manager().command_line_free_features()) - rproperties = self.common_properties (ps, self.requirements_) - - self.manager().targets().log( - "Common properties are '%s'" % str (rproperties)) - - if rproperties.get("<build>") != ["no"]: - - result = GenerateResult () - - properties = rproperties.non_dependency () - - (p, u) = self.generate_dependency_properties (rproperties.dependency (), rproperties) - properties += p - assert all(isinstance(p, property.Property) for p in properties) - usage_requirements = u - - (source_targets, u) = self.generate_dependency_targets (self.sources_, rproperties) - usage_requirements += u - - self.manager_.targets().log( - "Usage requirements for '%s' are '%s'" % (self.name_, usage_requirements)) - - # FIXME: - - rproperties = property_set.create(properties + usage_requirements) - usage_requirements = property_set.create (usage_requirements) - - self.manager_.targets().log( - "Build properties: '%s'" % str(rproperties)) - - source_targets += rproperties.get('<source>') - - # We might get duplicate sources, for example if - # we link to two library which have the same <library> in - # usage requirements. - # Use stable sort, since for some targets the order is - # important. E.g. RUN_PY target need python source to come - # first. - source_targets = unique(source_targets, stable=True) - - # FIXME: figure why this call messes up source_targets in-place - result = self.construct (self.name_, source_targets[:], rproperties) - - if result: - assert len(result) == 2 - gur = result [0] - result = result [1] - - if self.always_: - for t in result: - t.always() - - s = self.create_subvariant ( - result, - self.manager().virtual_targets().recent_targets(), ps, - source_targets, rproperties, usage_requirements) - self.manager().virtual_targets().clear_recent_targets() - - ur = self.compute_usage_requirements (s) - ur = ur.add (gur) - s.set_usage_requirements (ur) - - self.manager_.targets().log ( - "Usage requirements from '%s' are '%s'" % - (self.name(), str(rproperties))) - - self.generated_[ps] = GenerateResult (ur, result) - else: - self.generated_[ps] = GenerateResult (property_set.empty(), []) - else: - # If we just see <build>no, we cannot produce any reasonable - # diagnostics. The code that adds this property is expected - # to explain why a target is not built, for example using - # the configure.log-component-configuration function. - - # If this target fails to build, add <build>no to properties - # to cause any parent target to fail to build. Except that it - # - does not work now, since we check for <build>no only in - # common properties, but not in properties that came from - # dependencies - # - it's not clear if that's a good idea anyway. The alias - # target, for example, should not fail to build if a dependency - # fails. - self.generated_[ps] = GenerateResult( - property_set.create(["<build>no"]), []) - else: - self.manager().targets().log ("Already built") - - self.manager().targets().pop_target() - self.manager().targets().decrease_indent() - - return self.generated_[ps] - - def compute_usage_requirements (self, subvariant): - """ Given the set of generated targets, and refined build - properties, determines and sets appripriate usage requirements - on those targets. - """ - rproperties = subvariant.build_properties () - xusage_requirements =self.evaluate_requirements( - self.usage_requirements_, rproperties, "added") - - # We generate all dependency properties and add them, - # as well as their usage requirements, to result. - (r1, r2) = self.generate_dependency_properties(xusage_requirements.dependency (), rproperties) - extra = r1 + r2 - - result = property_set.create (xusage_requirements.non_dependency () + extra) - - # Propagate usage requirements we've got from sources, except - # for the <pch-header> and <pch-file> features. - # - # That feature specifies which pch file to use, and should apply - # only to direct dependents. Consider: - # - # pch pch1 : ... - # lib lib1 : ..... pch1 ; - # pch pch2 : - # lib lib2 : pch2 lib1 ; - # - # Here, lib2 should not get <pch-header> property from pch1. - # - # Essentially, when those two features are in usage requirements, - # they are propagated only to direct dependents. We might need - # a more general mechanism, but for now, only those two - # features are special. - raw = subvariant.sources_usage_requirements().raw() - raw = property.change(raw, "<pch-header>", None); - raw = property.change(raw, "<pch-file>", None); - result = result.add(property_set.create(raw)) - - return result - - def create_subvariant (self, root_targets, all_targets, - build_request, sources, - rproperties, usage_requirements): - """Creates a new subvariant-dg instances for 'targets' - - 'root-targets' the virtual targets will be returned to dependents - - 'all-targets' all virtual - targets created while building this main target - - 'build-request' is property-set instance with - requested build properties""" - - for e in root_targets: - e.root (True) - - s = Subvariant (self, build_request, sources, - rproperties, usage_requirements, all_targets) - - for v in all_targets: - if not v.creating_subvariant(): - v.creating_subvariant(s) - - return s - - def construct (self, name, source_targets, properties): - """ Constructs the virtual targets for this abstract targets and - the dependecy graph. Returns a tuple consisting of the properties and the list of virtual targets. - Should be overrided in derived classes. - """ - raise BaseException ("method should be defined in derived classes") - - -class TypedTarget (BasicTarget): - import generators - - def __init__ (self, name, project, type, sources, requirements, default_build, usage_requirements): - BasicTarget.__init__ (self, name, project, sources, requirements, default_build, usage_requirements) - self.type_ = type - - def __jam_repr__(self): - return b2.util.value_to_jam(self) - - def type (self): - return self.type_ - - def construct (self, name, source_targets, prop_set): - - r = generators.construct (self.project_, name, self.type_, - prop_set.add_raw(['<main-target-type>' + self.type_]), - source_targets, True) - - if not r: - print "warning: Unable to construct '%s'" % self.full_name () - - # Are there any top-level generators for this type/property set. - if not generators.find_viable_generators (self.type_, prop_set): - print "error: no generators were found for type '" + self.type_ + "'" - print "error: and the requested properties" - print "error: make sure you've configured the needed tools" - print "See http://boost.org/boost-build2/doc/html/bbv2/advanced/configuration.html" - - print "To debug this problem, try the --debug-generators option." - sys.exit(1) - - return r - -def apply_default_build(property_set, default_build): - # 1. First, see what properties from default_build - # are already present in property_set. - - specified_features = set(p.feature() for p in property_set.all()) - - defaults_to_apply = [] - for d in default_build.all(): - if not d.feature() in specified_features: - defaults_to_apply.append(d) - - # 2. If there's any defaults to be applied, form the new - # build request. Pass it throw 'expand-no-defaults', since - # default_build might contain "release debug", which will - # result in two property_sets. - result = [] - if defaults_to_apply: - - # We have to compress subproperties here to prevent - # property lists like: - # - # <toolset>msvc <toolset-msvc:version>7.1 <threading>multi - # - # from being expanded into: - # - # <toolset-msvc:version>7.1/<threading>multi - # <toolset>msvc/<toolset-msvc:version>7.1/<threading>multi - # - # due to cross-product property combination. That may - # be an indication that - # build_request.expand-no-defaults is the wrong rule - # to use here. - compressed = feature.compress_subproperties(property_set.all()) - - result = build_request.expand_no_defaults( - b2.build.property_set.create([p]) for p in (compressed + defaults_to_apply)) - - else: - result.append (property_set) - - return result - - -def create_typed_metatarget(name, type, sources, requirements, default_build, usage_requirements): - - from b2.manager import get_manager - t = get_manager().targets() - - project = get_manager().projects().current() - - return t.main_target_alternative( - TypedTarget(name, project, type, - t.main_target_sources(sources, name), - t.main_target_requirements(requirements, project), - t.main_target_default_build(default_build, project), - t.main_target_usage_requirements(usage_requirements, project))) - - -def create_metatarget(klass, name, sources, requirements=[], default_build=[], usage_requirements=[]): - from b2.manager import get_manager - t = get_manager().targets() - - project = get_manager().projects().current() - - return t.main_target_alternative( - klass(name, project, - t.main_target_sources(sources, name), - t.main_target_requirements(requirements, project), - t.main_target_default_build(default_build, project), - t.main_target_usage_requirements(usage_requirements, project))) - -def metatarget_function_for_class(class_): - - @bjam_signature((["name"], ["sources", "*"], ["requirements", "*"], - ["default_build", "*"], ["usage_requirements", "*"])) - def create_metatarget(name, sources, requirements = [], default_build = None, usage_requirements = []): - - from b2.manager import get_manager - t = get_manager().targets() - - project = get_manager().projects().current() - - return t.main_target_alternative( - class_(name, project, - t.main_target_sources(sources, name), - t.main_target_requirements(requirements, project), - t.main_target_default_build(default_build, project), - t.main_target_usage_requirements(usage_requirements, project))) - - return create_metatarget diff --git a/jam-files/boost-build/build/toolset.jam b/jam-files/boost-build/build/toolset.jam deleted file mode 100644 index f2036d99..00000000 --- a/jam-files/boost-build/build/toolset.jam +++ /dev/null @@ -1,502 +0,0 @@ -# Copyright 2003 Dave Abrahams -# Copyright 2005 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) - -# Support for toolset definition. - -import errors ; -import feature ; -import generators ; -import numbers ; -import path ; -import property ; -import regex ; -import sequence ; -import set ; - - -.flag-no = 1 ; - -.ignore-requirements = ; - -# This is used only for testing, to make sure we do not get random extra -# elements in paths. -if --ignore-toolset-requirements in [ modules.peek : ARGV ] -{ - .ignore-requirements = 1 ; -} - - -# Initializes an additional toolset-like module. First load the 'toolset-module' -# and then calls its 'init' rule with trailing arguments. -# -rule using ( toolset-module : * ) -{ - import $(toolset-module) ; - $(toolset-module).init $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ; -} - - -# Expands subfeatures in each property sets, e.g. '<toolset>gcc-3.2' will be -# converted to '<toolset>gcc/<toolset-version>3.2'. -# -local rule normalize-condition ( property-sets * ) -{ - local result ; - for local p in $(property-sets) - { - local split = [ feature.split $(p) ] ; - local expanded = [ feature.expand-subfeatures [ feature.split $(p) ] ] ; - result += $(expanded:J=/) ; - } - return $(result) ; -} - - -# Specifies if the 'flags' rule should check that the invoking module is the -# same as the module we are setting the flag for. 'v' can be either 'checked' or -# 'unchecked'. Subsequent call to 'pop-checking-for-flags-module' will restore -# the setting that was in effect before calling this rule. -# -rule push-checking-for-flags-module ( v ) -{ - .flags-module-checking = $(v) $(.flags-module-checking) ; -} - -rule pop-checking-for-flags-module ( ) -{ - .flags-module-checking = $(.flags-module-checking[2-]) ; -} - - -# Specifies the flags (variables) that must be set on targets under certain -# conditions, described by arguments. -# -rule flags ( - rule-or-module # If contains a dot, should be a rule name. The flags will - # be applied when that rule is used to set up build - # actions. - # - # If does not contain dot, should be a module name. The - # flag will be applied for all rules in that module. If - # module for rule is different from the calling module, an - # error is issued. - - variable-name # Variable that should be set on target. - condition * : # A condition when this flag should be applied. Should be a - # set of property sets. If one of those property sets is - # contained in the build properties, the flag will be used. - # Implied values are not allowed: "<toolset>gcc" should be - # used, not just "gcc". Subfeatures, like in - # "<toolset>gcc-3.2" are allowed. If left empty, the flag - # will be used unconditionally. - # - # Propery sets may use value-less properties ('<a>' vs. - # '<a>value') to match absent properties. This allows to - # separately match: - # - # <architecture>/<address-model>64 - # <architecture>ia64/<address-model> - # - # Where both features are optional. Without this syntax - # we would be forced to define "default" values. - - values * : # The value to add to variable. If <feature> is specified, - # then the value of 'feature' will be added. - unchecked ? # If value 'unchecked' is passed, will not test that flags - # are set for the calling module. - : hack-hack ? # For - # flags rule OPTIONS <cxx-abi> : -model ansi - # Treat <cxx-abi> as condition - # FIXME: ugly hack. -) -{ - local caller = [ CALLER_MODULE ] ; - if ! [ MATCH ".*([.]).*" : $(rule-or-module) ] - && [ MATCH "(Jamfile<.*)" : $(caller) ] - { - # Unqualified rule name, used inside Jamfile. Most likely used with - # 'make' or 'notfile' rules. This prevents setting flags on the entire - # Jamfile module (this will be considered as rule), but who cares? - # Probably, 'flags' rule should be split into 'flags' and - # 'flags-on-module'. - rule-or-module = $(caller).$(rule-or-module) ; - } - else - { - local module_ = [ MATCH "([^.]*).*" : $(rule-or-module) ] ; - if $(unchecked) != unchecked - && $(.flags-module-checking[1]) != unchecked - && $(module_) != $(caller) - { - errors.error "Module $(caller) attempted to set flags for module $(module_)" ; - } - } - - if $(condition) && ! $(condition:G=) && ! $(hack-hack) - { - # We have condition in the form '<feature>', that is, without value. - # That is an older syntax: - # flags gcc.link RPATH <dll-path> ; - # for compatibility, convert it to - # flags gcc.link RPATH : <dll-path> ; - values = $(condition) ; - condition = ; - } - - if $(condition) - { - property.validate-property-sets $(condition) ; - condition = [ normalize-condition $(condition) ] ; - } - - add-flag $(rule-or-module) : $(variable-name) : $(condition) : $(values) ; -} - - -# Adds a new flag setting with the specified values. Does no checking. -# -local rule add-flag ( rule-or-module : variable-name : condition * : values * ) -{ - .$(rule-or-module).flags += $(.flag-no) ; - - # Store all flags for a module. - local module_ = [ MATCH "([^.]*).*" : $(rule-or-module) ] ; - .module-flags.$(module_) += $(.flag-no) ; - # Store flag-no -> rule-or-module mapping. - .rule-or-module.$(.flag-no) = $(rule-or-module) ; - - .$(rule-or-module).variable.$(.flag-no) += $(variable-name) ; - .$(rule-or-module).values.$(.flag-no) += $(values) ; - .$(rule-or-module).condition.$(.flag-no) += $(condition) ; - - .flag-no = [ numbers.increment $(.flag-no) ] ; -} - - -# Returns the first element of 'property-sets' which is a subset of -# 'properties' or an empty list if no such element exists. -# -rule find-property-subset ( property-sets * : properties * ) -{ - # Cut property values off. - local prop-keys = $(properties:G) ; - - local result ; - for local s in $(property-sets) - { - if ! $(result) - { - # Handle value-less properties like '<architecture>' (compare with - # '<architecture>x86'). - - local set = [ feature.split $(s) ] ; - - # Find the set of features that - # - have no property specified in required property set - # - are omitted in the build property set. - local default-props ; - for local i in $(set) - { - # If $(i) is a value-less property it should match default value - # of an optional property. See the first line in the example - # below: - # - # property set properties result - # <a> <b>foo <b>foo match - # <a> <b>foo <a>foo <b>foo no match - # <a>foo <b>foo <b>foo no match - # <a>foo <b>foo <a>foo <b>foo match - if ! ( $(i:G=) || ( $(i:G) in $(prop-keys) ) ) - { - default-props += $(i) ; - } - } - - if $(set) in $(properties) $(default-props) - { - result = $(s) ; - } - } - } - return $(result) ; -} - - -# Returns a value to be added to some flag for some target based on the flag's -# value definition and the given target's property set. -# -rule handle-flag-value ( value * : properties * ) -{ - local result ; - if $(value:G) - { - local matches = [ property.select $(value) : $(properties) ] ; - for local p in $(matches) - { - local att = [ feature.attributes $(p:G) ] ; - if dependency in $(att) - { - # The value of a dependency feature is a target and needs to be - # actualized. - result += [ $(p:G=).actualize ] ; - } - else if path in $(att) || free in $(att) - { - local values ; - # Treat features with && in the value specially -- each - # &&-separated element is considered a separate value. This is - # needed to handle searched libraries or include paths, which - # may need to be in a specific order. - if ! [ MATCH (&&) : $(p:G=) ] - { - values = $(p:G=) ; - } - else - { - values = [ regex.split $(p:G=) "&&" ] ; - } - if path in $(att) - { - result += [ sequence.transform path.native : $(values) ] ; - } - else - { - result += $(values) ; - } - } - else - { - result += $(p:G=) ; - } - } - } - else - { - result += $(value) ; - } - return $(result) ; -} - - -# Given a rule name and a property set, returns a list of interleaved variables -# names and values which must be set on targets for that rule/property-set -# combination. -# -rule set-target-variables-aux ( rule-or-module : property-set ) -{ - local result ; - properties = [ $(property-set).raw ] ; - for local f in $(.$(rule-or-module).flags) - { - local variable = $(.$(rule-or-module).variable.$(f)) ; - local condition = $(.$(rule-or-module).condition.$(f)) ; - local values = $(.$(rule-or-module).values.$(f)) ; - - if ! $(condition) || - [ find-property-subset $(condition) : $(properties) ] - { - local processed ; - for local v in $(values) - { - # The value might be <feature-name> so needs special treatment. - processed += [ handle-flag-value $(v) : $(properties) ] ; - } - for local r in $(processed) - { - result += $(variable) $(r) ; - } - } - } - - # Strip away last dot separated part and recurse. - local next = [ MATCH ^(.+)\\.([^\\.])* : $(rule-or-module) ] ; - if $(next) - { - result += [ set-target-variables-aux $(next[1]) : $(property-set) ] ; - } - return $(result) ; -} - - -rule set-target-variables ( rule-or-module targets + : property-set ) -{ - properties = [ $(property-set).raw ] ; - local key = $(rule-or-module).$(property-set) ; - local settings = $(.stv.$(key)) ; - if ! $(settings) - { - settings = [ set-target-variables-aux $(rule-or-module) : - $(property-set) ] ; - - if ! $(settings) - { - settings = none ; - } - .stv.$(key) = $(settings) ; - } - - if $(settings) != none - { - local var-name = ; - for local name-or-value in $(settings) - { - if $(var-name) - { - $(var-name) on $(targets) += $(name-or-value) ; - var-name = ; - } - else - { - var-name = $(name-or-value) ; - } - } - } -} - - -# Make toolset 'toolset', defined in a module of the same name, inherit from -# 'base'. -# 1. The 'init' rule from 'base' is imported into 'toolset' with full name. -# Another 'init' is called, which forwards to the base one. -# 2. All generators from 'base' are cloned. The ids are adjusted and <toolset> -# property in requires is adjusted too. -# 3. All flags are inherited. -# 4. All rules are imported. -# -rule inherit ( toolset : base ) -{ - import $(base) ; - inherit-generators $(toolset) : $(base) ; - inherit-flags $(toolset) : $(base) ; - inherit-rules $(toolset) : $(base) ; -} - - -rule inherit-generators ( toolset properties * : base : generators-to-ignore * ) -{ - properties ?= <toolset>$(toolset) ; - local base-generators = [ generators.generators-for-toolset $(base) ] ; - for local g in $(base-generators) - { - local id = [ $(g).id ] ; - - if ! $(id) in $(generators-to-ignore) - { - # Some generator names have multiple periods in their name, so - # $(id:B=$(toolset)) does not generate the right new-id name. E.g. - # if id = gcc.compile.c++ then $(id:B=darwin) = darwin.c++, which is - # not what we want. Manually parse the base and suffix. If there is - # a better way to do this, I would love to see it. See also the - # register() rule in the generators module. - local base = $(id) ; - local suffix = "" ; - while $(base:S) - { - suffix = $(base:S)$(suffix) ; - base = $(base:B) ; - } - local new-id = $(toolset)$(suffix) ; - - generators.register [ $(g).clone $(new-id) : $(properties) ] ; - } - } -} - - -# Brings all flag definitions from the 'base' toolset into the 'toolset' -# toolset. Flag definitions whose conditions make use of properties in -# 'prohibited-properties' are ignored. Do not confuse property and feature, for -# example <debug-symbols>on and <debug-symbols>off, so blocking one of them does -# not block the other one. -# -# The flag conditions are not altered at all, so if a condition includes a name, -# or version of a base toolset, it will not ever match the inheriting toolset. -# When such flag settings must be inherited, define a rule in base toolset -# module and call it as needed. -# -rule inherit-flags ( toolset : base : prohibited-properties * : prohibited-vars * ) -{ - for local f in $(.module-flags.$(base)) - { - local rule-or-module = $(.rule-or-module.$(f)) ; - if ( [ set.difference - $(.$(rule-or-module).condition.$(f)) : - $(prohibited-properties) ] - || ! $(.$(rule-or-module).condition.$(f)) - ) && ( ! $(.$(rule-or-module).variable.$(f)) in $(prohibited-vars) ) - { - local rule_ = [ MATCH "[^.]*\.(.*)" : $(rule-or-module) ] ; - local new-rule-or-module ; - if $(rule_) - { - new-rule-or-module = $(toolset).$(rule_) ; - } - else - { - new-rule-or-module = $(toolset) ; - } - - add-flag - $(new-rule-or-module) - : $(.$(rule-or-module).variable.$(f)) - : $(.$(rule-or-module).condition.$(f)) - : $(.$(rule-or-module).values.$(f)) ; - } - } -} - - -rule inherit-rules ( toolset : base : localize ? ) -{ - # It appears that "action" creates a local rule. - local base-generators = [ generators.generators-for-toolset $(base) ] ; - local rules ; - for local g in $(base-generators) - { - rules += [ MATCH "[^.]*\.(.*)" : [ $(g).rule-name ] ] ; - } - rules = [ sequence.unique $(rules) ] ; - IMPORT $(base) : $(rules) : $(toolset) : $(rules) : $(localize) ; - IMPORT $(toolset) : $(rules) : : $(toolset).$(rules) ; -} - - -# Return the list of global 'toolset requirements'. Those requirements will be -# automatically added to the requirements of any main target. -# -rule requirements ( ) -{ - return $(.requirements) ; -} - - -# Adds elements to the list of global 'toolset requirements'. The requirements -# will be automatically added to the requirements for all main targets, as if -# they were specified literally. For best results, all requirements added should -# be conditional or indirect conditional. -# -rule add-requirements ( requirements * ) -{ - if ! $(.ignore-requirements) - { - .requirements += $(requirements) ; - } -} - - -rule __test__ ( ) -{ - import assert ; - local p = <b>0 <c>1 <d>2 <e>3 <f>4 ; - assert.result <c>1/<d>2/<e>3 : find-property-subset <c>1/<d>2/<e>3 <a>0/<b>0/<c>1 <d>2/<e>5 <a>9 : $(p) ; - assert.result : find-property-subset <a>0/<b>0/<c>9/<d>9/<e>5 <a>9 : $(p) ; - - local p-set = <a>/<b> <a>0/<b> <a>/<b>1 <a>0/<b>1 ; - assert.result <a>/<b> : find-property-subset $(p-set) : ; - assert.result <a>0/<b> : find-property-subset $(p-set) : <a>0 <c>2 ; - assert.result <a>/<b>1 : find-property-subset $(p-set) : <b>1 <c>2 ; - assert.result <a>0/<b>1 : find-property-subset $(p-set) : <a>0 <b>1 ; -} diff --git a/jam-files/boost-build/build/toolset.py b/jam-files/boost-build/build/toolset.py deleted file mode 100644 index b4267987..00000000 --- a/jam-files/boost-build/build/toolset.py +++ /dev/null @@ -1,398 +0,0 @@ -# Status: being ported by Vladimir Prus -# Base revision: 40958 -# -# Copyright 2003 Dave Abrahams -# Copyright 2005 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) - -""" Support for toolset definition. -""" - -import feature, property, generators, property_set -import b2.util.set -from b2.util import cached, qualify_jam_action -from b2.util.utility import * -from b2.util import bjam_signature -from b2.manager import get_manager - -__re_split_last_segment = re.compile (r'^(.+)\.([^\.])*') -__re_two_ampersands = re.compile ('(&&)') -__re_first_segment = re.compile ('([^.]*).*') -__re_first_group = re.compile (r'[^.]*\.(.*)') - -# Flag is a mechanism to set a value -# A single toolset flag. Specifies that when certain -# properties are in build property set, certain values -# should be appended to some variable. -# -# A flag applies to a specific action in specific module. -# The list of all flags for a module is stored, and each -# flag further contains the name of the rule it applies -# for, -class Flag: - - def __init__(self, variable_name, values, condition, rule = None): - self.variable_name = variable_name - self.values = values - self.condition = condition - self.rule = rule - - def __str__(self): - return("Flag(" + str(self.variable_name) + ", " + str(self.values) +\ - ", " + str(self.condition) + ", " + str(self.rule) + ")") - -def reset (): - """ Clear the module state. This is mainly for testing purposes. - """ - global __module_flags, __flags, __stv - - # Mapping from module name to a list of all flags that apply - # to either that module directly, or to any rule in that module. - # Each element of the list is Flag instance. - # So, for module named xxx this might contain flags for 'xxx', - # for 'xxx.compile', for 'xxx.compile.c++', etc. - __module_flags = {} - - # Mapping from specific rule or module name to a list of Flag instances - # that apply to that name. - # Say, it might contain flags for 'xxx.compile.c++'. If there are - # entries for module name 'xxx', they are flags for 'xxx' itself, - # not including any rules in that module. - __flags = {} - - # A cache for varaible settings. The key is generated from the rule name and the properties. - __stv = {} - -reset () - -# FIXME: --ignore-toolset-requirements -# FIXME: using - -# FIXME push-checking-for-flags-module .... -# FIXME: investigate existing uses of 'hack-hack' parameter -# in jam code. - -@bjam_signature((["rule_or_module", "variable_name", "condition", "*"], - ["values", "*"])) -def flags(rule_or_module, variable_name, condition, values = []): - """ Specifies the flags (variables) that must be set on targets under certain - conditions, described by arguments. - rule_or_module: If contains dot, should be a rule name. - The flags will be applied when that rule is - used to set up build actions. - - If does not contain dot, should be a module name. - The flags will be applied for all rules in that - module. - If module for rule is different from the calling - module, an error is issued. - - variable_name: Variable that should be set on target - - condition A condition when this flag should be applied. - Should be set of property sets. If one of - those property sets is contained in build - properties, the flag will be used. - Implied values are not allowed: - "<toolset>gcc" should be used, not just - "gcc". Subfeatures, like in "<toolset>gcc-3.2" - are allowed. If left empty, the flag will - always used. - - Propery sets may use value-less properties - ('<a>' vs. '<a>value') to match absent - properties. This allows to separately match - - <architecture>/<address-model>64 - <architecture>ia64/<address-model> - - Where both features are optional. Without this - syntax we'd be forced to define "default" value. - - values: The value to add to variable. If <feature> - is specified, then the value of 'feature' - will be added. - """ - caller = bjam.caller()[:-1] - if not '.' in rule_or_module and caller.startswith("Jamfile"): - # Unqualified rule name, used inside Jamfile. Most likely used with - # 'make' or 'notfile' rules. This prevents setting flags on the entire - # Jamfile module (this will be considered as rule), but who cares? - # Probably, 'flags' rule should be split into 'flags' and - # 'flags-on-module'. - rule_or_module = qualify_jam_action(rule_or_module, caller) - else: - # FIXME: revive checking that we don't set flags for a different - # module unintentionally - pass - - if condition and not replace_grist (condition, ''): - # We have condition in the form '<feature>', that is, without - # value. That's a previous syntax: - # - # flags gcc.link RPATH <dll-path> ; - # for compatibility, convert it to - # flags gcc.link RPATH : <dll-path> ; - values = [ condition ] - condition = None - - if condition: - transformed = [] - for c in condition: - # FIXME: 'split' might be a too raw tool here. - pl = [property.create_from_string(s) for s in c.split('/')] - pl = feature.expand_subfeatures(pl); - transformed.append(property_set.create(pl)) - condition = transformed - - property.validate_property_sets(condition) - - __add_flag (rule_or_module, variable_name, condition, values) - -def set_target_variables (manager, rule_or_module, targets, ps): - """ - """ - settings = __set_target_variables_aux(manager, rule_or_module, ps) - - if settings: - for s in settings: - for target in targets: - manager.engine ().set_target_variable (target, s [0], s[1], True) - -def find_satisfied_condition(conditions, ps): - """Returns the first element of 'property-sets' which is a subset of - 'properties', or an empty list if no such element exists.""" - - features = set(p.feature() for p in ps.all()) - - for condition in conditions: - - found_all = True - for i in condition.all(): - - found = False - if i.value(): - found = i.value() in ps.get(i.feature()) - else: - # Handle value-less properties like '<architecture>' (compare with - # '<architecture>x86'). - # If $(i) is a value-less property it should match default - # value of an optional property. See the first line in the - # example below: - # - # property set properties result - # <a> <b>foo <b>foo match - # <a> <b>foo <a>foo <b>foo no match - # <a>foo <b>foo <b>foo no match - # <a>foo <b>foo <a>foo <b>foo match - found = not i.feature() in features - - found_all = found_all and found - - if found_all: - return condition - - return None - - -def register (toolset): - """ Registers a new toolset. - """ - feature.extend('toolset', [toolset]) - -def inherit_generators (toolset, properties, base, generators_to_ignore = []): - if not properties: - properties = [replace_grist (toolset, '<toolset>')] - - base_generators = generators.generators_for_toolset(base) - - for g in base_generators: - id = g.id() - - if not id in generators_to_ignore: - # Some generator names have multiple periods in their name, so - # $(id:B=$(toolset)) doesn't generate the right new_id name. - # e.g. if id = gcc.compile.c++, $(id:B=darwin) = darwin.c++, - # which is not what we want. Manually parse the base and suffix - # (if there's a better way to do this, I'd love to see it.) - # See also register in module generators. - (base, suffix) = split_action_id(id) - - new_id = toolset + '.' + suffix - - generators.register(g.clone(new_id, properties)) - -def inherit_flags(toolset, base, prohibited_properties = []): - """Brings all flag definitions from the 'base' toolset into the 'toolset' - toolset. Flag definitions whose conditions make use of properties in - 'prohibited-properties' are ignored. Don't confuse property and feature, for - example <debug-symbols>on and <debug-symbols>off, so blocking one of them does - not block the other one. - - The flag conditions are not altered at all, so if a condition includes a name, - or version of a base toolset, it won't ever match the inheriting toolset. When - such flag settings must be inherited, define a rule in base toolset module and - call it as needed.""" - for f in __module_flags.get(base, []): - - if not f.condition or b2.util.set.difference(f.condition, prohibited_properties): - match = __re_first_group.match(f.rule) - rule_ = None - if match: - rule_ = match.group(1) - - new_rule_or_module = '' - - if rule_: - new_rule_or_module = toolset + '.' + rule_ - else: - new_rule_or_module = toolset - - __add_flag (new_rule_or_module, f.variable_name, f.condition, f.values) - -def inherit_rules (toolset, base): - pass - # FIXME: do something about this. -# base_generators = generators.generators_for_toolset (base) - -# import action - -# ids = [] -# for g in base_generators: -# (old_toolset, id) = split_action_id (g.id ()) -# ids.append (id) ; - -# new_actions = [] - -# engine = get_manager().engine() - # FIXME: do this! -# for action in engine.action.values(): -# pass -# (old_toolset, id) = split_action_id(action.action_name) -# -# if old_toolset == base: -# new_actions.append ((id, value [0], value [1])) -# -# for a in new_actions: -# action.register (toolset + '.' + a [0], a [1], a [2]) - - # TODO: how to deal with this? -# IMPORT $(base) : $(rules) : $(toolset) : $(rules) : localized ; -# # Import the rules to the global scope -# IMPORT $(toolset) : $(rules) : : $(toolset).$(rules) ; -# } -# - -###################################################################################### -# Private functions - -@cached -def __set_target_variables_aux (manager, rule_or_module, ps): - """ Given a rule name and a property set, returns a list of tuples of - variables names and values, which must be set on targets for that - rule/properties combination. - """ - result = [] - - for f in __flags.get(rule_or_module, []): - - if not f.condition or find_satisfied_condition (f.condition, ps): - processed = [] - for v in f.values: - # The value might be <feature-name> so needs special - # treatment. - processed += __handle_flag_value (manager, v, ps) - - for r in processed: - result.append ((f.variable_name, r)) - - # strip away last dot separated part and recurse. - next = __re_split_last_segment.match(rule_or_module) - - if next: - result.extend(__set_target_variables_aux( - manager, next.group(1), ps)) - - return result - -def __handle_flag_value (manager, value, ps): - result = [] - - if get_grist (value): - f = feature.get(value) - values = ps.get(f) - - for value in values: - - if f.dependency(): - # the value of a dependency feature is a target - # and must be actualized - result.append(value.actualize()) - - elif f.path() or f.free(): - - # Treat features with && in the value - # specially -- each &&-separated element is considered - # separate value. This is needed to handle searched - # libraries, which must be in specific order. - if not __re_two_ampersands.search(value): - result.append(value) - - else: - result.extend(value.split ('&&')) - else: - result.append (ungristed) - else: - result.append (value) - - return result - -def __add_flag (rule_or_module, variable_name, condition, values): - """ Adds a new flag setting with the specified values. - Does no checking. - """ - f = Flag(variable_name, values, condition, rule_or_module) - - # Grab the name of the module - m = __re_first_segment.match (rule_or_module) - assert m - module = m.group(1) - - __module_flags.setdefault(m, []).append(f) - __flags.setdefault(rule_or_module, []).append(f) - -__requirements = [] - -def requirements(): - """Return the list of global 'toolset requirements'. - Those requirements will be automatically added to the requirements of any main target.""" - return __requirements - -def add_requirements(requirements): - """Adds elements to the list of global 'toolset requirements'. The requirements - will be automatically added to the requirements for all main targets, as if - they were specified literally. For best results, all requirements added should - be conditional or indirect conditional.""" - - #if ! $(.ignore-requirements) - #{ - print "XXXX", requirements - __requirements.extend(requirements) - #} - -# Make toolset 'toolset', defined in a module of the same name, -# inherit from 'base' -# 1. The 'init' rule from 'base' is imported into 'toolset' with full -# name. Another 'init' is called, which forwards to the base one. -# 2. All generators from 'base' are cloned. The ids are adjusted and -# <toolset> property in requires is adjusted too -# 3. All flags are inherited -# 4. All rules are imported. -def inherit(toolset, base): - get_manager().projects().load_module(base, []); - - inherit_generators(toolset, [], base) - inherit_flags(toolset, base) - inherit_rules(toolset, base) diff --git a/jam-files/boost-build/build/type.jam b/jam-files/boost-build/build/type.jam deleted file mode 100644 index 1a7a5782..00000000 --- a/jam-files/boost-build/build/type.jam +++ /dev/null @@ -1,425 +0,0 @@ -# Copyright 2002, 2003 Dave Abrahams -# 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) - -# Deals with target type declaration and defines target class which supports -# typed targets. - -import "class" : new ; -import errors ; -import feature ; -import generators : * ; -import project ; -import property ; -import scanner ; -import os ; - -# The following import would create a circular dependency: -# project -> project-root -> builtin -> type -> targets -> project -# import targets ; - -# The feature is optional so it would never get added implicitly. It is used -# only for internal purposes and in all cases we want to use it explicitly. -feature.feature target-type : : composite optional ; - -feature.feature main-target-type : : optional incidental ; -feature.feature base-target-type : : composite optional free ; - - -# Registers a target type, possible derived from a 'base-type'. Providing a list -# of 'suffixes' here is a shortcut for separately calling the register-suffixes -# rule with the given suffixes and the set-generated-target-suffix rule with the -# first given suffix. -# -rule register ( type : suffixes * : base-type ? ) -{ - # Type names cannot contain hyphens, because when used as feature-values - # they would be interpreted as composite features which need to be - # decomposed. - switch $(type) - { - case *-* : errors.error "type name \"$(type)\" contains a hyphen" ; - } - - if $(type) in $(.types) - { - errors.error "Type $(type) is already registered." ; - } - else - { - .types += $(type) ; - .base.$(type) = $(base-type) ; - .derived.$(base-type) += $(type) ; - - if $(suffixes)-is-not-empty - { - # Specify mapping from suffixes to type. - register-suffixes $(suffixes) : $(type) ; - # By default generated targets of 'type' will use the first of - #'suffixes'. This may be overriden. - set-generated-target-suffix $(type) : : $(suffixes[1]) ; - } - - feature.extend target-type : $(type) ; - feature.extend main-target-type : $(type) ; - feature.extend base-target-type : $(type) ; - - feature.compose <target-type>$(type) : $(base-type:G=<base-target-type>) ; - feature.compose <base-target-type>$(type) : <base-target-type>$(base-type) ; - - # We used to declare the main target rule only when a 'main' parameter - # has been specified. However, it is hard to decide that a type will - # *never* need a main target rule and so from time to time we needed to - # make yet another type 'main'. So now a main target rule is defined for - # each type. - main-rule-name = [ type-to-rule-name $(type) ] ; - .main-target-type.$(main-rule-name) = $(type) ; - IMPORT $(__name__) : main-target-rule : : $(main-rule-name) ; - - # 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) ; - } -} - - -# Given a type, returns the name of the main target rule which creates targets -# of that type. -# -rule type-to-rule-name ( type ) -{ - # Lowercase everything. Convert underscores to dashes. - import regex ; - local n = [ regex.split $(type:L) "_" ] ; - return $(n:J=-) ; -} - - -# Given a main target rule name, returns the type for which it creates targets. -# -rule type-from-rule-name ( rule-name ) -{ - return $(.main-target-type.$(rule-name)) ; -} - - -# Specifies that files with suffix from 'suffixes' be recognized as targets of -# type 'type'. Issues an error if a different type is already specified for any -# of the suffixes. -# -rule register-suffixes ( suffixes + : type ) -{ - for local s in $(suffixes) - { - if ! $(.type.$(s)) - { - .type.$(s) = $(type) ; - } - else if $(.type.$(s)) != $(type) - { - errors.error Attempting to specify multiple types for suffix - \"$(s)\" : "Old type $(.type.$(s)), New type $(type)" ; - } - } -} - - -# Returns true iff type has been registered. -# -rule registered ( type ) -{ - if $(type) in $(.types) - { - return true ; - } -} - - -# Issues an error if 'type' is unknown. -# -rule validate ( type ) -{ - if ! [ registered $(type) ] - { - errors.error "Unknown target type $(type)" ; - } -} - - -# Sets a scanner class that will be used for this 'type'. -# -rule set-scanner ( type : scanner ) -{ - validate $(type) ; - .scanner.$(type) = $(scanner) ; -} - - -# Returns a scanner instance appropriate to 'type' and 'properties'. -# -rule get-scanner ( type : property-set ) -{ - if $(.scanner.$(type)) - { - return [ scanner.get $(.scanner.$(type)) : $(property-set) ] ; - } -} - - -# Returns a base type for the given type or nothing in case the given type is -# not derived. -# -rule base ( type ) -{ - return $(.base.$(type)) ; -} - - -# Returns the given type and all of its base types in order of their distance -# from type. -# -rule all-bases ( type ) -{ - local result = $(type) ; - while $(type) - { - type = [ base $(type) ] ; - result += $(type) ; - } - return $(result) ; -} - - -# Returns the given type and all of its derived types in order of their distance -# from type. -# -rule all-derived ( type ) -{ - local result = $(type) ; - for local d in $(.derived.$(type)) - { - result += [ all-derived $(d) ] ; - } - return $(result) ; -} - - -# Returns true if 'type' is equal to 'base' or has 'base' as its direct or -# indirect base. -# -rule is-derived ( type base ) -{ - if $(base) in [ all-bases $(type) ] - { - return true ; - } -} - -# Returns true if 'type' is either derived from or is equal to 'base'. -# -# TODO: It might be that is-derived and is-subtype were meant to be different -# rules - one returning true for type = base and one not, but as currently -# implemented they are actually the same. Clean this up. -# -rule is-subtype ( type base ) -{ - return [ is-derived $(type) $(base) ] ; -} - - -# Store suffixes for generated targets. -.suffixes = [ new property-map ] ; - -# Store prefixes for generated targets (e.g. "lib" for library). -.prefixes = [ new property-map ] ; - - -# Sets a file suffix to be used when generating a target of 'type' with the -# specified properties. Can be called with no properties if no suffix has -# already been specified for the 'type'. The 'suffix' parameter can be an empty -# string ("") to indicate that no suffix should be used. -# -# Note that this does not cause files with 'suffix' to be automatically -# recognized as being of 'type'. Two different types can use the same suffix for -# their generated files but only one type can be auto-detected for a file with -# that suffix. User should explicitly specify which one using the -# register-suffixes rule. -# -rule set-generated-target-suffix ( type : properties * : suffix ) -{ - set-generated-target-ps suffix : $(type) : $(properties) : $(suffix) ; -} - - -# Change the suffix previously registered for this type/properties combination. -# If suffix is not yet specified, sets it. -# -rule change-generated-target-suffix ( type : properties * : suffix ) -{ - change-generated-target-ps suffix : $(type) : $(properties) : $(suffix) ; -} - - -# Returns the suffix used when generating a file of 'type' with the given -# properties. -# -rule generated-target-suffix ( type : property-set ) -{ - return [ generated-target-ps suffix : $(type) : $(property-set) ] ; -} - - -# Sets a target prefix that should be used when generating targets of 'type' -# with the specified properties. Can be called with empty properties if no -# prefix for 'type' has been specified yet. -# -# The 'prefix' parameter can be empty string ("") to indicate that no prefix -# should be used. -# -# Usage example: library names use the "lib" prefix on unix. -# -rule set-generated-target-prefix ( type : properties * : prefix ) -{ - set-generated-target-ps prefix : $(type) : $(properties) : $(prefix) ; -} - - -# Change the prefix previously registered for this type/properties combination. -# If prefix is not yet specified, sets it. -# -rule change-generated-target-prefix ( type : properties * : prefix ) -{ - change-generated-target-ps prefix : $(type) : $(properties) : $(prefix) ; -} - - -rule generated-target-prefix ( type : property-set ) -{ - return [ generated-target-ps prefix : $(type) : $(property-set) ] ; -} - - -# Common rules for prefix/suffix provisioning follow. - -local rule set-generated-target-ps ( ps : type : properties * : psval ) -{ - properties = <target-type>$(type) $(properties) ; - $(.$(ps)es).insert $(properties) : $(psval) ; -} - - -local rule change-generated-target-ps ( ps : type : properties * : psval ) -{ - properties = <target-type>$(type) $(properties) ; - local prev = [ $(.$(ps)es).find-replace $(properties) : $(psval) ] ; - if ! $(prev) - { - set-generated-target-ps $(ps) : $(type) : $(properties) : $(psval) ; - } -} - - -# Returns either prefix or suffix (as indicated by 'ps') that should be used -# when generating a target of 'type' with the specified properties. Parameter -# 'ps' can be either "prefix" or "suffix". If no prefix/suffix is specified for -# 'type', returns prefix/suffix for base type, if any. -# -local rule generated-target-ps-real ( ps : type : properties * ) -{ - local result ; - local found ; - while $(type) && ! $(found) - { - result = [ $(.$(ps)es).find <target-type>$(type) $(properties) ] ; - # If the prefix/suffix is explicitly set to an empty string, we consider - # prefix/suffix to be found. If we were not to compare with "", there - # would be no way to specify an empty prefix/suffix. - if $(result)-is-not-empty - { - found = true ; - } - type = $(.base.$(type)) ; - } - if $(result) = "" - { - result = ; - } - return $(result) ; -} - - -local rule generated-target-ps ( ps : type : property-set ) -{ - local key = .$(ps).$(type).$(property-set) ; - local v = $($(key)) ; - if ! $(v) - { - v = [ generated-target-ps-real $(ps) : $(type) : [ $(property-set).raw ] - ] ; - if ! $(v) - { - v = none ; - } - $(key) = $(v) ; - } - - if $(v) != none - { - return $(v) ; - } -} - - -# Returns file type given its name. If there are several dots in filename, tries -# each suffix. E.g. for name of "file.so.1.2" suffixes "2", "1", and "so" will -# be tried. -# -rule type ( filename ) -{ - if [ os.name ] in NT CYGWIN - { - filename = $(filename:L) ; - } - local type ; - while ! $(type) && $(filename:S) - { - local suffix = $(filename:S) ; - type = $(.type$(suffix)) ; - filename = $(filename:S=) ; - } - return $(type) ; -} - - -# Rule used to construct all main targets. Note that this rule gets imported -# into the global namespace under different alias names and the exact target -# type to construct is selected based on the alias used to actually invoke this -# rule. -# -rule main-target-rule ( name : sources * : requirements * : default-build * : - usage-requirements * ) -{ - # First discover the required target type based on the exact alias used to - # invoke this rule. - local bt = [ BACKTRACE 1 ] ; - local rulename = $(bt[4]) ; - local target-type = [ type-from-rule-name $(rulename) ] ; - - # This is a circular module dependency and so must be imported here. - import targets ; - - return [ targets.create-typed-target $(target-type) : [ project.current ] : - $(name) : $(sources) : $(requirements) : $(default-build) : - $(usage-requirements) ] ; -} - - -rule __test__ ( ) -{ - import assert ; - - # TODO: Add tests for all the is-derived, is-base & related type relation - # checking rules. -} diff --git a/jam-files/boost-build/build/type.py b/jam-files/boost-build/build/type.py deleted file mode 100644 index ddb7ba09..00000000 --- a/jam-files/boost-build/build/type.py +++ /dev/null @@ -1,313 +0,0 @@ -# Status: ported. -# Base revision: 45462. - -# 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. - - - -import re -import os -import os.path -from b2.util.utility import replace_grist, os_name -from b2.exceptions import * -from b2.build import feature, property, scanner -from b2.util import bjam_signature - - -__re_hyphen = re.compile ('-') - -def __register_features (): - """ Register features need by this module. - """ - # The feature is optional so that it is never implicitly added. - # It's used only for internal purposes, and in all cases we - # want to explicitly use it. - feature.feature ('target-type', [], ['composite', 'optional']) - feature.feature ('main-target-type', [], ['optional', 'incidental']) - feature.feature ('base-target-type', [], ['composite', 'optional', 'free']) - -def reset (): - """ Clear the module state. This is mainly for testing purposes. - Note that this must be called _after_ resetting the module 'feature'. - """ - global __prefixes_suffixes, __suffixes_to_types, __types, __rule_names_to_types, __target_suffixes_cache - - __register_features () - - # Stores suffixes for generated targets. - __prefixes_suffixes = [property.PropertyMap(), property.PropertyMap()] - - # Maps suffixes to types - __suffixes_to_types = {} - - # A map with all the registered types, indexed by the type name - # Each entry is a dictionary with following values: - # 'base': the name of base type or None if type has no base - # 'derived': a list of names of type which derive from this one - # 'scanner': the scanner class registered for this type, if any - __types = {} - - # Caches suffixes for targets with certain properties. - __target_suffixes_cache = {} - -reset () - -@bjam_signature((["type"], ["suffixes", "*"], ["base_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) - -# FIXME: quick hack. -def type_from_rule_name(rule_name): - return rule_name.upper().replace("-", "_") - - -def register_suffixes (suffixes, type): - """ Specifies that targets with suffix from 'suffixes' have the type 'type'. - If a different type is already specified for any of syffixes, issues an error. - """ - for s in suffixes: - if __suffixes_to_types.has_key (s): - old_type = __suffixes_to_types [s] - if old_type != type: - raise BaseException ('Attempting to specify type for suffix "%s"\nOld type: "%s", New type "%s"' % (s, old_type, type)) - else: - __suffixes_to_types [s] = type - -def registered (type): - """ Returns true iff type has been registered. - """ - return __types.has_key (type) - -def validate (type): - """ Issues an error if 'type' is unknown. - """ - if not registered (type): - raise BaseException ("Unknown target type '%s'" % type) - -def set_scanner (type, scanner): - """ Sets a scanner class that will be used for this 'type'. - """ - validate (type) - __types [type]['scanner'] = scanner - -def get_scanner (type, prop_set): - """ Returns a scanner instance appropriate to 'type' and 'property_set'. - """ - if registered (type): - scanner_type = __types [type]['scanner'] - if scanner_type: - return scanner.get (scanner_type, prop_set.raw ()) - pass - - return None - -def base(type): - """Returns a base type for the given type or nothing in case the given type is - not derived.""" - - return __types[type]['base'] - -def all_bases (type): - """ Returns type and all of its bases, in the order of their distance from type. - """ - result = [] - while type: - result.append (type) - type = __types [type]['base'] - - return result - -def all_derived (type): - """ Returns type and all classes that derive from it, in the order of their distance from type. - """ - result = [type] - for d in __types [type]['derived']: - result.extend (all_derived (d)) - - return result - -def is_derived (type, base): - """ Returns true if 'type' is 'base' or has 'base' as its direct or indirect base. - """ - # TODO: this isn't very efficient, especially for bases close to type - if base in all_bases (type): - return True - else: - return False - -def is_subtype (type, base): - """ Same as is_derived. Should be removed. - """ - # TODO: remove this method - return is_derived (type, base) - -@bjam_signature((["type"], ["properties", "*"], ["suffix"])) -def set_generated_target_suffix (type, properties, suffix): - """ Sets a target suffix that should be used when generating target - of 'type' with the specified properties. Can be called with - empty properties if no suffix for 'type' was specified yet. - This does not automatically specify that files 'suffix' have - 'type' --- two different types can use the same suffix for - generating, but only one type should be auto-detected for - a file with that suffix. User should explicitly specify which - one. - - The 'suffix' parameter can be empty string ("") to indicate that - no suffix should be used. - """ - set_generated_target_ps(1, type, properties, suffix) - - - -def change_generated_target_suffix (type, properties, suffix): - """ Change the suffix previously registered for this type/properties - combination. If suffix is not yet specified, sets it. - """ - change_generated_target_ps(1, type, properties, suffix) - -def generated_target_suffix(type, properties): - return generated_target_ps(1, type, properties) - -# Sets a target prefix that should be used when generating targets of 'type' -# with the specified properties. Can be called with empty properties if no -# prefix for 'type' has been specified yet. -# -# The 'prefix' parameter can be empty string ("") to indicate that no prefix -# should be used. -# -# Usage example: library names use the "lib" prefix on unix. -@bjam_signature((["type"], ["properties", "*"], ["suffix"])) -def set_generated_target_prefix(type, properties, prefix): - set_generated_target_ps(0, type, properties, prefix) - -# Change the prefix previously registered for this type/properties combination. -# If prefix is not yet specified, sets it. -def change_generated_target_prefix(type, properties, prefix): - change_generated_target_ps(0, type, properties, prefix) - -def generated_target_prefix(type, properties): - return generated_target_ps(0, type, properties) - -def set_generated_target_ps(is_suffix, type, properties, val): - properties.append ('<target-type>' + type) - __prefixes_suffixes[is_suffix].insert (properties, val) - -def change_generated_target_ps(is_suffix, type, properties, val): - properties.append ('<target-type>' + type) - prev = __prefixes_suffixes[is_suffix].find_replace(properties, val) - if not prev: - set_generated_target_ps(is_suffix, type, properties, val) - -# Returns either prefix or suffix (as indicated by 'is_suffix') that should be used -# when generating a target of 'type' with the specified properties. -# If no prefix/suffix is specified for 'type', returns prefix/suffix for -# base type, if any. -def generated_target_ps_real(is_suffix, type, properties): - - result = '' - found = False - while type and not found: - result = __prefixes_suffixes[is_suffix].find (['<target-type>' + type] + properties) - - # Note that if the string is empty (""), but not null, we consider - # suffix found. Setting prefix or suffix to empty string is fine. - if result is not None: - found = True - - type = __types [type]['base'] - - if not result: - result = '' - return result - -def generated_target_ps(is_suffix, type, prop_set): - """ Returns suffix that should be used when generating target of 'type', - with the specified properties. If not suffix were specified for - 'type', returns suffix for base type, if any. - """ - key = (is_suffix, type, prop_set) - v = __target_suffixes_cache.get(key, None) - - if not v: - v = generated_target_ps_real(is_suffix, type, prop_set.raw()) - __target_suffixes_cache [key] = v - - return v - -def type(filename): - """ Returns file type given it's name. If there are several dots in filename, - tries each suffix. E.g. for name of "file.so.1.2" suffixes "2", "1", and - "so" will be tried. - """ - while 1: - filename, suffix = os.path.splitext (filename) - if not suffix: return None - suffix = suffix[1:] - - if __suffixes_to_types.has_key(suffix): - return __suffixes_to_types[suffix] - -# NOTE: moved from tools/types/register -def register_type (type, suffixes, base_type = None, os = []): - """ Register the given type on the specified OSes, or on remaining OSes - if os is not specified. This rule is injected into each of the type - modules for the sake of convenience. - """ - if registered (type): - return - - if not os or os_name () in os: - register (type, suffixes, base_type) diff --git a/jam-files/boost-build/build/version.jam b/jam-files/boost-build/build/version.jam deleted file mode 100644 index 7626ddda..00000000 --- a/jam-files/boost-build/build/version.jam +++ /dev/null @@ -1,161 +0,0 @@ -# Copyright 2002, 2003, 2004, 2006 Vladimir Prus -# Copyright 2008 Jurko Gospodnetic -# 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 errors ; -import numbers ; - -major = "2011" ; -minor = "04" ; - -rule boost-build ( ) -{ - return "$(major).$(minor)-svn" ; -} - -rule print ( ) -{ - if [ verify-engine-version ] - { - ECHO "Boost.Build" [ boost-build ] ; - } -} - -rule verify-engine-version ( ) -{ - local v = [ modules.peek : JAM_VERSION ] ; - - if $(v[1]) != $(major) || $(v[2]) != $(minor) - { - local argv = [ modules.peek : ARGV ] ; - local e = $(argv[1]) ; - local l = [ modules.binding version ] ; - l = $(l:D) ; - l = $(l:D) ; - ECHO "warning: mismatched versions of Boost.Build engine and core" ; - ECHO "warning: Boost.Build engine ($(e)) is $(v:J=.)" ; - ECHO "warning: Boost.Build core (at $(l)) is" [ boost-build ] ; - } - else - { - return true ; - } -} - - - -# Utility rule for testing whether all elements in a sequence are equal to 0. -# -local rule is-all-zeroes ( sequence * ) -{ - local result = "true" ; - for local e in $(sequence) - { - if $(e) != "0" - { - result = "" ; - } - } - return $(result) ; -} - - -# Returns "true" if the first version is less than the second one. -# -rule version-less ( lhs + : rhs + ) -{ - numbers.check $(lhs) ; - numbers.check $(rhs) ; - - local done ; - local result ; - - while ! $(done) && $(lhs) && $(rhs) - { - if [ numbers.less $(lhs[1]) $(rhs[1]) ] - { - done = "true" ; - result = "true" ; - } - else if [ numbers.less $(rhs[1]) $(lhs[1]) ] - { - done = "true" ; - } - else - { - lhs = $(lhs[2-]) ; - rhs = $(rhs[2-]) ; - } - } - if ( ! $(done) && ! $(lhs) && ! [ is-all-zeroes $(rhs) ] ) - { - result = "true" ; - } - - return $(result) ; -} - - -# Returns "true" if the current JAM version version is at least the given -# version. -# -rule check-jam-version ( version + ) -{ - local version-tag = $(version:J=.) ; - if ! $(version-tag) - { - errors.error Invalid version specifier: : $(version:E="(undefined)") ; - } - - if ! $(.jam-version-check.$(version-tag))-is-not-empty - { - local jam-version = [ modules.peek : JAM_VERSION ] ; - if ! $(jam-version) - { - errors.error "Unable to deduce Boost Jam version. Your Boost Jam" - "installation is most likely terribly outdated." ; - } - .jam-version-check.$(version-tag) = "true" ; - if [ version-less [ modules.peek : JAM_VERSION ] : $(version) ] - { - .jam-version-check.$(version-tag) = "" ; - } - } - return $(.jam-version-check.$(version-tag)) ; -} - - -rule __test__ ( ) -{ - import assert ; - - local jam-version = [ modules.peek : JAM_VERSION ] ; - local future-version = $(jam-version) ; - future-version += "1" ; - - assert.true check-jam-version $(jam-version) ; - assert.false check-jam-version $(future-version) ; - - assert.true version-less 0 : 1 ; - assert.false version-less 0 : 0 ; - assert.true version-less 1 : 2 ; - assert.false version-less 1 : 1 ; - assert.false version-less 2 : 1 ; - assert.true version-less 3 1 20 : 3 4 10 ; - assert.false version-less 3 1 10 : 3 1 10 ; - assert.false version-less 3 4 10 : 3 1 20 ; - assert.true version-less 3 1 20 5 1 : 3 4 10 ; - assert.false version-less 3 1 10 5 1 : 3 1 10 ; - assert.false version-less 3 4 10 5 1 : 3 1 20 ; - assert.true version-less 3 1 20 : 3 4 10 5 1 ; - assert.true version-less 3 1 10 : 3 1 10 5 1 ; - assert.false version-less 3 4 10 : 3 1 20 5 1 ; - assert.false version-less 3 1 10 : 3 1 10 0 0 ; - assert.false version-less 3 1 10 0 0 : 3 1 10 ; - assert.false version-less 3 1 10 0 : 3 1 10 0 0 ; - assert.false version-less 3 1 10 0 : 03 1 10 0 0 ; - assert.false version-less 03 1 10 0 : 3 1 10 0 0 ; - - # TODO: Add tests for invalid input data being sent to version-less. -} diff --git a/jam-files/boost-build/build/virtual-target.jam b/jam-files/boost-build/build/virtual-target.jam deleted file mode 100644 index 2e8446bc..00000000 --- a/jam-files/boost-build/build/virtual-target.jam +++ /dev/null @@ -1,1317 +0,0 @@ -# Copyright 2003 Dave Abrahams -# Copyright 2005, 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) - -# Implements virtual targets, which correspond to actual files created during a -# build, but are not yet targets in Jam sense. They are needed, for example, -# when searching for possible transformation sequences, when it is not yet known -# whether a particular target should be created at all. - -import "class" : new ; -import errors ; -import path ; -import sequence ; -import set ; -import type ; -import utility ; - - -# +--------------------------+ -# | virtual-target | -# +==========================+ -# | actualize | -# +--------------------------+ -# | actualize-action() = 0 | -# | actualize-location() = 0 | -# +----------------+---------+ -# | -# ^ -# / \ -# +-+-+ -# | -# +---------------------+ +-------+--------------+ -# | action | | abstract-file-target | -# +=====================| * +======================+ -# | action-name | +--+ action | -# | properties | | +----------------------+ -# +---------------------+--+ | actualize-action() | -# | actualize() |0..1 +-----------+----------+ -# | path() | | -# | adjust-properties() | sources | -# | actualize-sources() | targets | -# +------+--------------+ ^ -# | / \ -# ^ +-+-+ -# / \ | -# +-+-+ +-------------+-------------+ -# | | | -# | +------+---------------+ +--------+-------------+ -# | | file-target | | searched-lib-target | -# | +======================+ +======================+ -# | | actualize-location() | | actualize-location() | -# | +----------------------+ +----------------------+ -# | -# +-+------------------------------+ -# | | -# +----+----------------+ +---------+-----------+ -# | compile-action | | link-action | -# +=====================+ +=====================+ -# | adjust-properties() | | adjust-properties() | -# +---------------------+ | actualize-sources() | -# +---------------------+ -# -# The 'compile-action' and 'link-action' classes are not defined here but in -# builtin.jam modules. They are shown in the diagram to give the big picture. - - -# Models a potential target. It can be converted into a Jam target and used in -# building, if needed. However, it can be also dropped, which allows us to -# search for different transformations and select only one. -# -class virtual-target -{ - import scanner ; - import sequence ; - import utility ; - import virtual-target ; - - rule __init__ ( - name # Target/project name. - : project # Project to which this target belongs. - ) - { - self.name = $(name) ; - self.project = $(project) ; - self.dependencies = ; - } - - # Name of this target. - # - rule name ( ) - { - return $(self.name) ; - } - - # Project of this target. - # - rule project ( ) - { - return $(self.project) ; - } - - # Adds additional 'virtual-target' instances this one depends on. - # - rule depends ( d + ) - { - self.dependencies = [ sequence.merge $(self.dependencies) : - [ sequence.insertion-sort $(d) ] ] ; - } - - rule dependencies ( ) - { - return $(self.dependencies) ; - } - - rule always ( ) - { - .always = 1 ; - } - - # 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 the actual target, which will depend on the actual target and - # be associated with a '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 the actual target is returned. - # - rule actualize ( scanner ? ) - { - local actual-name = [ actualize-no-scanner ] ; - - if $(.always) - { - ALWAYS $(actual-name) ; - } - - if ! $(scanner) - { - return $(actual-name) ; - } - else - { - # Add the scanner instance to the grist for name. - local g = [ sequence.join - [ utility.ungrist $(actual-name:G) ] $(scanner) : - ] ; - local name = $(actual-name:G=$(g)) ; - - if ! $(self.made.$(name)) - { - self.made.$(name) = true ; - - DEPENDS $(name) : $(actual-name) ; - - actualize-location $(name) ; - - scanner.install $(scanner) : $(name) $(__name__) ; - } - return $(name) ; - } - } - -# private: (overridables) - - # Sets up build actions for 'target'. Should call appropriate rules and set - # target variables. - # - rule actualize-action ( target ) - { - errors.error "method should be defined in derived classes" ; - } - - # Sets up variables on 'target' which specify its location. - # - rule actualize-location ( target ) - { - errors.error "method should be defined in derived classes" ; - } - - # If the target is a generated one, returns the path where it will be - # generated. Otherwise, returns an empty list. - # - rule path ( ) - { - errors.error "method should be defined in derived classes" ; - } - - # Returns the actual target name to be used in case when no scanner is - # involved. - # - rule actual-name ( ) - { - errors.error "method should be defined in derived classes" ; - } - -# implementation - rule actualize-no-scanner ( ) - { - # In fact, we just need to merge virtual-target with - # abstract-file-target as the latter is the only class derived from the - # former. But that has been left for later. - - errors.error "method should be defined in derived classes" ; - } -} - - -# Target corresponding to a file. The exact mapping for file is not yet -# specified in this class. (TODO: Actually, the class name could be better...) -# -# May be a source file (when no action is specified) or a derived file -# (otherwise). -# -# The target's grist is a concatenation of its project's location, action -# properties (for derived targets) and, optionally, value identifying the main -# target. -# -class abstract-file-target : virtual-target -{ - import project ; - import regex ; - import sequence ; - import path ; - import type ; - import property-set ; - import indirect ; - - rule __init__ ( - name # Target's name. - exact ? # If non-empty, the name is exactly the name created file - # should have. Otherwise, the '__init__' method will add a - # suffix obtained from 'type' by calling - # 'type.generated-target-suffix'. - : type ? # Target's type. - : project - : action ? - ) - { - virtual-target.__init__ $(name) : $(project) ; - - self.type = $(type) ; - self.action = $(action) ; - if $(action) - { - $(action).add-targets $(__name__) ; - - if $(self.type) && ! $(exact) - { - _adjust-name $(name) ; - } - } - } - - rule type ( ) - { - return $(self.type) ; - } - - # Sets the path. When generating target name, it will override any path - # computation from properties. - # - rule set-path ( path ) - { - self.path = [ path.native $(path) ] ; - } - - # Returns the currently set action. - # - rule action ( ) - { - return $(self.action) ; - } - - # Sets/gets the 'root' flag. Target is root if it directly corresponds to - # some variant of a main target. - # - rule root ( set ? ) - { - if $(set) - { - self.root = true ; - } - return $(self.root) ; - } - - # Gets or sets the subvariant which created this target. Subvariant is set - # when target is brought into existance and is never changed after that. In - # particular, if a target is shared by a subvariant, only the first is - # stored. - # - rule creating-subvariant ( s ? # If specified, specifies the value to set, - # which should be a 'subvariant' class - # instance. - ) - { - if $(s) && ! $(self.creating-subvariant) - { - self.creating-subvariant = $(s) ; - } - return $(self.creating-subvariant) ; - } - - rule actualize-action ( target ) - { - if $(self.action) - { - $(self.action).actualize ; - } - } - - # Return a human-readable representation of this target. If this target has - # an action, that is: - # - # { <action-name>-<self.name>.<self.type> <action-sources>... } - # - # otherwise, it is: - # - # { <self.name>.<self.type> } - # - rule str ( ) - { - local action = [ action ] ; - local name-dot-type = [ sequence.join $(self.name) "." $(self.type) ] ; - - if $(action) - { - local sources = [ $(action).sources ] ; - local action-name = [ $(action).action-name ] ; - - local ss ; - for local s in $(sources) - { - ss += [ $(s).str ] ; - } - - return "{" $(action-name)-$(name-dot-type) $(ss) "}" ; - } - else - { - return "{" $(name-dot-type) "}" ; - } - } - - rule less ( a ) - { - if [ str ] < [ $(a).str ] - { - return true ; - } - } - - rule equal ( a ) - { - if [ str ] = [ $(a).str ] - { - return true ; - } - } - -# private: - rule actual-name ( ) - { - if ! $(self.actual-name) - { - local grist = [ grist ] ; - local basename = [ path.native $(self.name) ] ; - self.actual-name = <$(grist)>$(basename) ; - } - return $(self.actual-name) ; - } - - # Helper to 'actual-name', above. Computes a unique prefix used to - # distinguish this target from other targets with the same name creating - # different files. - # - rule grist ( ) - { - # Depending on target, there may be different approaches to generating - # unique prefixes. We generate prefixes in the form: - # <one letter approach code> <the actual prefix> - local path = [ path ] ; - if $(path) - { - # The target will be generated to a known path. Just use the path - # for identification, since path is as unique as it can get. - return p$(path) ; - } - else - { - # File is either source, which will be searched for, or is not a - # file at all. Use the location of project for distinguishing. - local project-location = [ $(self.project).get location ] ; - local location-grist = [ sequence.join [ regex.split - $(project-location) "/" ] : "!" ] ; - - if $(self.action) - { - local ps = [ $(self.action).properties ] ; - local property-grist = [ $(ps).as-path ] ; - # 'property-grist' can be empty when 'ps' is an empty property - # set. - if $(property-grist) - { - location-grist = $(location-grist)/$(property-grist) ; - } - } - - return l$(location-grist) ; - } - } - - # Given the target name specified in constructor, returns the name which - # should be really used, by looking at the <tag> properties. Tag properties - # need to be specified as <tag>@rule-name. This makes Boost Build call the - # specified rule with the target name, type and properties to get the new - # name. If no <tag> property is specified or the rule specified by <tag> - # returns nothing, returns the result of calling - # virtual-target.add-prefix-and-suffix. - # - rule _adjust-name ( specified-name ) - { - local ps ; - if $(self.action) - { - ps = [ $(self.action).properties ] ; - } - else - { - ps = [ property-set.empty ] ; - } - - # We add ourselves to the properties so that any tag rule can get more - # direct information about the target than just that available through - # the properties. This is useful in implementing name changes based on - # the sources of the target. For example to make unique names of object - # files based on the source file. --grafik - ps = [ property-set.create [ $(ps).raw ] <target>$(__name__) ] ; - - local tag = [ $(ps).get <tag> ] ; - - if $(tag) - { - local rule-name = [ MATCH ^@(.*) : $(tag) ] ; - if $(rule-name) - { - if $(tag[2]) - { - errors.error "<tag>@rulename is present but is not the only" - "<tag> feature" ; - } - - self.name = [ indirect.call $(rule-name) $(specified-name) - : $(self.type) : $(ps) ] ; - } - else - { - errors.error - "The value of the <tag> feature must be '@rule-name'" ; - } - } - - # If there is no tag or the tag rule returned nothing. - if ! $(tag) || ! $(self.name) - { - self.name = [ virtual-target.add-prefix-and-suffix $(specified-name) - : $(self.type) : $(ps) ] ; - } - } - - rule actualize-no-scanner ( ) - { - local name = [ actual-name ] ; - - # Do anything only on the first invocation. - if ! $(self.made.$(name)) - { - self.made.$(name) = true ; - - if $(self.action) - { - # For non-derived target, we do not care if there are several - # virtual targets that refer to the same name. One case when - # this is unavoidable is when the file name is main.cpp and two - # targets have types CPP (for compiling) and MOCCABLE_CPP (for - # conversion to H via Qt tools). - virtual-target.register-actual-name $(name) : $(__name__) ; - } - - for local i in $(self.dependencies) - { - DEPENDS $(name) : [ $(i).actualize ] ; - } - - actualize-location $(name) ; - actualize-action $(name) ; - } - return $(name) ; - } -} - - -# Appends the suffix appropriate to 'type/property-set' combination to the -# specified name and returns the result. -# -rule add-prefix-and-suffix ( specified-name : type ? : property-set ) -{ - local suffix = [ type.generated-target-suffix $(type) : $(property-set) ] ; - - # Handle suffixes for which no leading dot is desired. Those are specified - # by enclosing them in <...>. Needed by python so it can create "_d.so" - # extensions, for example. - if $(suffix:G) - { - suffix = [ utility.ungrist $(suffix) ] ; - } - else - { - suffix = .$(suffix) ; - } - - local prefix = [ type.generated-target-prefix $(type) : $(property-set) ] ; - - if [ MATCH ^($(prefix)) : $(specified-name) ] - { - prefix = ; - } - return $(prefix:E="")$(specified-name)$(suffix:E="") ; -} - - -# File targets with explicitly known location. -# -# The file path is determined as -# * Value passed to the 'set-path' method, if any. -# * For derived files, project's build dir, joined with components that -# describe action properties. If free properties are not equal to the -# project's reference properties an element with the name of the main -# target is added. -# * For source files, project's source dir. -# -# The file suffix is determined as: -# * The value passed to the 'suffix' method, if any. -# * The suffix corresponding to the target's type. -# -class file-target : abstract-file-target -{ - import "class" : new ; - import common ; - import errors ; - - rule __init__ ( - name exact ? - : type ? # Optional type for this target. - : project - : action ? - : path ? - ) - { - abstract-file-target.__init__ $(name) $(exact) : $(type) : $(project) : - $(action) ; - - self.path = $(path) ; - } - - rule clone-with-different-type ( new-type ) - { - return [ new file-target $(self.name) exact : $(new-type) : - $(self.project) : $(self.action) : $(self.path) ] ; - } - - rule actualize-location ( target ) - { - if $(self.action) - { - # This is a derived file. - local path = [ path ] ; - LOCATE on $(target) = $(path) ; - - # Make sure the path exists. - DEPENDS $(target) : $(path) ; - common.MkDir $(path) ; - - # It is possible that the target name includes a directory too, for - # example when installing headers. Create that directory. - if $(target:D) - { - local d = $(target:D) ; - d = $(d:R=$(path)) ; - DEPENDS $(target) : $(d) ; - common.MkDir $(d) ; - } - - # For a real file target, we create a fake target depending on the - # real target. This allows us to run - # - # bjam hello.o - # - # without trying to guess the name of the real target. Note that the - # target has no directory name and uses a special <e> grist. - # - # First, that means that "bjam hello.o" will build all known hello.o - # targets. Second, the <e> grist makes sure this target will not be - # confused with other targets, for example, if we have subdir 'test' - # with target 'test' in it that includes a 'test.o' file, then the - # target for directory will be just 'test' the target for test.o - # will be <ptest/bin/gcc/debug>test.o and the target we create below - # will be <e>test.o - DEPENDS $(target:G=e) : $(target) ; - # Allow bjam <path-to-file>/<file> to work. This will not catch all - # possible ways to refer to the path (relative/absolute, extra ".", - # various "..", but should help in obvious cases. - DEPENDS $(target:G=e:R=$(path)) : $(target) ; - } - else - { - SEARCH on $(target) = [ path.native $(self.path) ] ; - } - } - - # Returns the directory for this target. - # - rule path ( ) - { - if ! $(self.path) - { - if $(self.action) - { - local p = [ $(self.action).properties ] ; - local path,relative-to-build-dir = [ $(p).target-path ] ; - local path = $(path,relative-to-build-dir[1]) ; - local relative-to-build-dir = $(path,relative-to-build-dir[2]) ; - - if $(relative-to-build-dir) - { - path = [ path.join [ $(self.project).build-dir ] $(path) ] ; - } - - self.path = [ path.native $(path) ] ; - } - } - return $(self.path) ; - } -} - - -class notfile-target : abstract-file-target -{ - rule __init__ ( name : project : action ? ) - { - abstract-file-target.__init__ $(name) : : $(project) : $(action) ; - } - - # Returns nothing to indicate that the target's path is not known. - # - rule path ( ) - { - return ; - } - - rule actualize-location ( target ) - { - NOTFILE $(target) ; - ALWAYS $(target) ; - # TEMPORARY $(target) ; - NOUPDATE $(target) ; - } -} - - -# Class representing an action. Both 'targets' and 'sources' should list -# instances of 'virtual-target'. Action name should name a rule with this -# prototype: -# rule action-name ( targets + : sources * : properties * ) -# Targets and sources are passed as actual Jam targets. The rule may not -# establish additional dependency relationships. -# -class action -{ - import "class" ; - import errors ; - import type ; - import toolset ; - import property-set ; - import indirect ; - import path ; - import set : difference ; - - rule __init__ ( sources * : action-name + : property-set ? ) - { - self.sources = $(sources) ; - - self.action-name = [ indirect.make-qualified $(action-name) ] ; - - if ! $(property-set) - { - property-set = [ property-set.empty ] ; - } - - if ! [ class.is-instance $(property-set) ] - { - errors.error "Property set instance required" ; - } - - self.properties = $(property-set) ; - } - - rule add-targets ( targets * ) - { - self.targets += $(targets) ; - } - - rule replace-targets ( old-targets * : new-targets * ) - { - self.targets = [ set.difference $(self.targets) : $(old-targets) ] ; - self.targets += $(new-targets) ; - } - - rule targets ( ) - { - return $(self.targets) ; - } - - rule sources ( ) - { - return $(self.sources) ; - } - - rule action-name ( ) - { - return $(self.action-name) ; - } - - rule properties ( ) - { - return $(self.properties) ; - } - - # Generates actual build instructions. - # - rule actualize ( ) - { - if ! $(self.actualized) - { - self.actualized = true ; - - local ps = [ properties ] ; - local properties = [ adjust-properties $(ps) ] ; - - local actual-targets ; - for local i in [ targets ] - { - actual-targets += [ $(i).actualize ] ; - } - - actualize-sources [ sources ] : $(properties) ; - - DEPENDS $(actual-targets) : $(self.actual-sources) - $(self.dependency-only-sources) ; - - # This works around a bug with -j and actions that - # produce multiple target, where: - # - dependency on the first output is found, and - # the action is started - # - dependency on the second output is found, and - # bjam noticed that command is already running - # - instead of waiting for the command, dependents - # of the second targets are immediately updated. - if $(actual-targets[2]) - { - INCLUDES $(actual-targets) : $(actual-targets) ; - } - - # Action name can include additional argument to rule, which should - # not be passed to 'set-target-variables' - toolset.set-target-variables - [ indirect.get-rule $(self.action-name[1]) ] $(actual-targets) - : $(properties) ; - - # Reflect ourselves in a variable for the target. This allows - # looking up additional info for the action given the raw target. - # For example to debug or output action information from action - # rules. - .action on $(actual-targets) = $(__name__) ; - - indirect.call $(self.action-name) $(actual-targets) - : $(self.actual-sources) : [ $(properties).raw ] ; - - # Since we set up the creating action here, we set up the action for - # cleaning up as well. - common.Clean clean-all : $(actual-targets) ; - } - } - - # Helper for 'actualize-sources'. For each passed source, actualizes it with - # the appropriate scanner. Returns the actualized virtual targets. - # - rule actualize-source-type ( sources * : property-set ) - { - local result = ; - for local i in $(sources) - { - local scanner ; - if [ $(i).type ] - { - scanner = [ type.get-scanner [ $(i).type ] : $(property-set) ] ; - } - result += [ $(i).actualize $(scanner) ] ; - } - return $(result) ; - } - - # Creates actual Jam targets for sources. Initializes the following member - # variables: - # 'self.actual-sources' -- sources passed to the updating action. - # 'self.dependency-only-sources' -- sources marked as dependencies, but - # are not used otherwise. - # - # New values will be *appended* to the variables. They may be non-empty if - # caller wants it. - # - rule actualize-sources ( sources * : property-set ) - { - local dependencies = [ $(self.properties).get <dependency> ] ; - - self.dependency-only-sources += - [ actualize-source-type $(dependencies) : $(property-set) ] ; - self.actual-sources += - [ actualize-source-type $(sources) : $(property-set) ] ; - - # This is used to help bjam find dependencies in generated headers and - # other main targets, e.g. in: - # - # make a.h : ....... ; - # exe hello : hello.cpp : <implicit-dependency>a.h ; - # - # For bjam to find the dependency the generated target must be - # actualized (i.e. have its Jam target constructed). In the above case, - # if we are building just hello ("bjam hello"), 'a.h' will not be - # actualized unless we do it here. - local implicit = [ $(self.properties).get <implicit-dependency> ] ; - for local i in $(implicit) - { - $(i:G=).actualize ; - } - } - - # Determines real properties when trying to build with 'properties'. This is - # the last chance to fix properties, for example to adjust includes to get - # generated headers correctly. Default implementation simply returns its - # argument. - # - rule adjust-properties ( property-set ) - { - return $(property-set) ; - } -} - - -# Action class which does nothing --- it produces the targets with specific -# properties out of nowhere. It is needed to distinguish virtual targets with -# different properties that are known to exist and have no actions which create -# them. -# -class null-action : action -{ - rule __init__ ( property-set ? ) - { - action.__init__ : .no-action : $(property-set) ; - } - - rule actualize ( ) - { - if ! $(self.actualized) - { - self.actualized = true ; - for local i in [ targets ] - { - $(i).actualize ; - } - } - } -} - - -# Class which acts exactly like 'action', except that its sources are not -# scanned for dependencies. -# -class non-scanning-action : action -{ - rule __init__ ( sources * : action-name + : property-set ? ) - { - action.__init__ $(sources) : $(action-name) : $(property-set) ; - } - - rule actualize-source-type ( sources * : property-set ) - { - local result ; - for local i in $(sources) - { - result += [ $(i).actualize ] ; - } - return $(result) ; - } -} - - -# Creates a virtual target with an appropriate name and type from 'file'. If a -# target with that name in that project already exists, returns that already -# created target. -# -# FIXME: a more correct way would be to compute the path to the file, based on -# name and source location for the project, and use that path to determine if -# the target has already been created. This logic should be shared with how we -# usually find targets identified by a specific target id. It should also be -# updated to work correctly when the file is specified using both relative and -# absolute paths. -# -# TODO: passing a project with all virtual targets is starting to be annoying. -# -rule from-file ( file : file-loc : project ) -{ - import type ; # Had to do this here to break a circular dependency. - - # Check whether we already created a target corresponding to this file. - local path = [ path.root [ path.root $(file) $(file-loc) ] [ path.pwd ] ] ; - - if $(.files.$(path)) - { - return $(.files.$(path)) ; - } - else - { - local name = [ path.make $(file) ] ; - local type = [ type.type $(file) ] ; - local result ; - - result = [ new file-target $(file) : $(type) : $(project) : : - $(file-loc) ] ; - - .files.$(path) = $(result) ; - return $(result) ; - } -} - - -# Registers a new virtual target. Checks if there is already a registered target -# with the same name, type, project and subvariant properties as well as the -# same sources and equal action. If such target is found it is returned and a -# new 'target' is not registered. Otherwise, 'target' is registered and -# returned. -# -rule register ( target ) -{ - local signature = [ sequence.join - [ $(target).path ] [ $(target).name ] : - ] ; - - local result ; - for local t in $(.cache.$(signature)) - { - local a1 = [ $(t).action ] ; - local a2 = [ $(target).action ] ; - - if ! $(result) - { - if ! $(a1) && ! $(a2) - { - result = $(t) ; - } - else - { - if $(a1) && $(a2) && - ( [ $(a1).action-name ] = [ $(a2).action-name ] ) && - ( [ $(a1).sources ] = [ $(a2).sources ] ) - { - local ps1 = [ $(a1).properties ] ; - local ps2 = [ $(a2).properties ] ; - local p1 = [ $(ps1).base ] [ $(ps1).free ] [ set.difference - [ $(ps1).dependency ] : [ $(ps1).incidental ] ] ; - local p2 = [ $(ps2).base ] [ $(ps2).free ] [ set.difference - [ $(ps2).dependency ] : [ $(ps2).incidental ] ] ; - if $(p1) = $(p2) - { - result = $(t) ; - } - } - } - } - } - - if ! $(result) - { - .cache.$(signature) += $(target) ; - result = $(target) ; - } - - .recent-targets += $(result) ; - .all-targets += $(result) ; - - return $(result) ; -} - - -# Each target returned by 'register' is added to the .recent-targets list, -# returned by this function. This allows us to find all virtual targets created -# when building a specific main target, even those constructed only as -# intermediate targets. -# -rule recent-targets ( ) -{ - return $(.recent-targets) ; -} - - -rule clear-recent-targets ( ) -{ - .recent-targets = ; -} - - -# Returns all virtual targets ever created. -# -rule all-targets ( ) -{ - return $(.all-targets) ; -} - - -# Returns all targets from 'targets' with types equal to 'type' or derived from -# it. -# -rule select-by-type ( type : targets * ) -{ - local result ; - for local t in $(targets) - { - if [ type.is-subtype [ $(t).type ] $(type) ] - { - result += $(t) ; - } - } - return $(result) ; -} - - -rule register-actual-name ( actual-name : virtual-target ) -{ - if $(.actual.$(actual-name)) - { - local cs1 = [ $(.actual.$(actual-name)).creating-subvariant ] ; - local cs2 = [ $(virtual-target).creating-subvariant ] ; - local cmt1 = [ $(cs1).main-target ] ; - local cmt2 = [ $(cs2).main-target ] ; - - local action1 = [ $(.actual.$(actual-name)).action ] ; - local action2 = [ $(virtual-target).action ] ; - local properties-added ; - local properties-removed ; - if $(action1) && $(action2) - { - local p1 = [ $(action1).properties ] ; - p1 = [ $(p1).raw ] ; - local p2 = [ $(action2).properties ] ; - p2 = [ $(p2).raw ] ; - properties-removed = [ set.difference $(p1) : $(p2) ] ; - properties-removed ?= "none" ; - properties-added = [ set.difference $(p2) : $(p1) ] ; - properties-added ?= "none" ; - } - errors.error "Duplicate name of actual target:" $(actual-name) - : "previous virtual target" [ $(.actual.$(actual-name)).str ] - : "created from" [ $(cmt1).full-name ] - : "another virtual target" [ $(virtual-target).str ] - : "created from" [ $(cmt2).full-name ] - : "added properties:" $(properties-added) - : "removed properties:" $(properties-removed) ; - } - else - { - .actual.$(actual-name) = $(virtual-target) ; - } -} - - -# Traverses the dependency graph of 'target' and return all targets that will be -# created before this one is created. If the root of some dependency graph is -# found during traversal, it is either included or not, depending on the -# 'include-roots' value. In either case traversal stops at root targets, i.e. -# root target sources are not traversed. -# -rule traverse ( target : include-roots ? : include-sources ? ) -{ - local result ; - if [ $(target).action ] - { - local action = [ $(target).action ] ; - # This includes the 'target' as well. - result += [ $(action).targets ] ; - - for local t in [ $(action).sources ] - { - if ! [ $(t).root ] - { - result += [ traverse $(t) : $(include-roots) : $(include-sources) ] ; - } - else if $(include-roots) - { - result += $(t) ; - } - } - } - else if $(include-sources) - { - result = $(target) ; - } - return $(result) ; -} - - -# Takes an 'action' instance and creates a new instance of it and all targets -# produced by the action. The rule-name and properties are set to -# 'new-rule-name' and 'new-properties', if those are specified. Returns the -# cloned action. -# -rule clone-action ( action : new-project : new-action-name ? : new-properties ? ) -{ - if ! $(new-action-name) - { - new-action-name = [ $(action).action-name ] ; - } - if ! $(new-properties) - { - new-properties = [ $(action).properties ] ; - } - - local action-class = [ modules.peek $(action) : __class__ ] ; - local cloned-action = [ class.new $(action-class) - [ $(action).sources ] : $(new-action-name) : $(new-properties) ] ; - - local cloned-targets ; - for local target in [ $(action).targets ] - { - local n = [ $(target).name ] ; - # Do not modify produced target names. - local cloned-target = [ class.new file-target $(n) exact : - [ $(target).type ] : $(new-project) : $(cloned-action) ] ; - local d = [ $(target).dependencies ] ; - if $(d) - { - $(cloned-target).depends $(d) ; - } - $(cloned-target).root [ $(target).root ] ; - $(cloned-target).creating-subvariant [ $(target).creating-subvariant ] ; - - cloned-targets += $(cloned-target) ; - } - - return $(cloned-action) ; -} - - -class subvariant -{ - import sequence ; - import type ; - - rule __init__ ( main-target # The instance of main-target class. - : property-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 = $(property-set) ; - self.sources = $(sources) ; - self.build-properties = $(build-properties) ; - self.sources-usage-requirements = $(sources-usage-requirements) ; - self.created-targets = $(created-targets) ; - - # Pre-compose a list of other dependency graphs this one depends on. - local deps = [ $(build-properties).get <implicit-dependency> ] ; - for local d in $(deps) - { - self.other-dg += [ $(d:G=).creating-subvariant ] ; - } - - self.other-dg = [ sequence.unique $(self.other-dg) ] ; - } - - rule main-target ( ) - { - return $(self.main-target) ; - } - - rule created-targets ( ) - { - return $(self.created-targets) ; - } - - rule requested-properties ( ) - { - return $(self.properties) ; - } - - rule build-properties ( ) - { - return $(self.build-properties) ; - } - - rule sources-usage-requirements ( ) - { - return $(self.sources-usage-requirements) ; - } - - rule set-usage-requirements ( usage-requirements ) - { - self.usage-requirements = $(usage-requirements) ; - } - - rule usage-requirements ( ) - { - return $(self.usage-requirements) ; - } - - # Returns all targets referenced by this subvariant, either directly or - # indirectly, and either as sources, or as dependency properties. Targets - # referred to using the dependency property are returned as properties, not - # targets. - # - rule all-referenced-targets ( theset ) - { - # Find directly referenced targets. - local deps = [ $(self.build-properties).dependency ] ; - local all-targets = $(self.sources) $(deps) ; - - # Find other subvariants. - local r ; - for local t in $(all-targets) - { - if ! [ $(theset).contains $(t) ] - { - $(theset).add $(t) ; - r += [ $(t:G=).creating-subvariant ] ; - } - } - r = [ sequence.unique $(r) ] ; - for local s in $(r) - { - if $(s) != $(__name__) - { - $(s).all-referenced-targets $(theset) ; - } - } - } - - # Returns the properties specifying implicit include paths to generated - # headers. This traverses all targets in this subvariant and subvariants - # referred by <implcit-dependecy> properties. For all targets of type - # 'target-type' (or for all targets, if 'target-type' is not specified), the - # result will contain <$(feature)>path-to-that-target. - # - rule implicit-includes ( feature : target-type ? ) - { - local key = ii$(feature)-$(target-type:E="") ; - if ! $($(key))-is-not-empty - { - local target-paths = [ all-target-directories $(target-type) ] ; - target-paths = [ sequence.unique $(target-paths) ] ; - local result = $(target-paths:G=$(feature)) ; - if ! $(result) - { - result = "" ; - } - $(key) = $(result) ; - } - if $($(key)) = "" - { - return ; - } - else - { - return $($(key)) ; - } - } - - rule all-target-directories ( target-type ? ) - { - if ! $(self.target-directories) - { - compute-target-directories $(target-type) ; - } - return $(self.target-directories) ; - } - - rule compute-target-directories ( target-type ? ) - { - local result ; - for local t in $(self.created-targets) - { - # Skip targets of the wrong type. - if ! $(target-type) || - [ type.is-derived [ $(t).type ] $(target-type) ] - { - result = [ sequence.merge $(result) : [ $(t).path ] ] ; - } - } - for local d in $(self.other-dg) - { - result += [ $(d).all-target-directories $(target-type) ] ; - } - self.target-directories = $(result) ; - } -} diff --git a/jam-files/boost-build/build/virtual_target.py b/jam-files/boost-build/build/virtual_target.py deleted file mode 100644 index 51dff037..00000000 --- a/jam-files/boost-build/build/virtual_target.py +++ /dev/null @@ -1,1118 +0,0 @@ -# Status: ported. -# Base revision: 64488. -# -# 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. - -# Implements virtual targets, which correspond to actual files created during -# build, but are not yet targets in Jam sense. They are needed, for example, -# when searching for possible transormation sequences, when it's not known -# if particular target should be created at all. -# -# -# +--------------------------+ -# | VirtualTarget | -# +==========================+ -# | actualize | -# +--------------------------+ -# | actualize_action() = 0 | -# | actualize_location() = 0 | -# +----------------+---------+ -# | -# ^ -# / \ -# +-+-+ -# | -# +---------------------+ +-------+--------------+ -# | Action | | AbstractFileTarget | -# +=====================| * +======================+ -# | action_name | +--+ action | -# | properties | | +----------------------+ -# +---------------------+--+ | actualize_action() | -# | actualize() |0..1 +-----------+----------+ -# | path() | | -# | adjust_properties() | sources | -# | actualize_sources() | targets | -# +------+--------------+ ^ -# | / \ -# ^ +-+-+ -# / \ | -# +-+-+ +-------------+-------------+ -# | | | -# | +------+---------------+ +--------+-------------+ -# | | FileTarget | | SearchedLibTarget | -# | +======================+ +======================+ -# | | actualize-location() | | actualize-location() | -# | +----------------------+ +----------------------+ -# | -# +-+------------------------------+ -# | | -# +----+----------------+ +---------+-----------+ -# | CompileAction | | LinkAction | -# +=====================+ +=====================+ -# | adjust_properties() | | adjust_properties() | -# +---------------------+ | actualize_sources() | -# +---------------------+ -# -# The 'CompileAction' and 'LinkAction' classes are defined not here, -# but in builtin.jam modules. They are shown in the diagram to give -# the big picture. - -import bjam - -import re -import os.path -import string -import types - -from b2.util import path, utility, set -from b2.util.utility import add_grist, get_grist, ungrist, replace_grist, get_value -from b2.util.sequence import unique -from b2.tools import common -from b2.exceptions import * -import b2.build.type -import b2.build.property_set as property_set - -import b2.build.property as property - -from b2.manager import get_manager -from b2.util import bjam_signature - -__re_starts_with_at = re.compile ('^@(.*)') - -class VirtualTargetRegistry: - def __init__ (self, manager): - self.manager_ = manager - - # A cache for FileTargets - self.files_ = {} - - # A cache for targets. - self.cache_ = {} - - # A map of actual names to virtual targets. - # Used to make sure we don't associate same - # actual target to two virtual targets. - self.actual_ = {} - - self.recent_targets_ = [] - - # All targets ever registed - self.all_targets_ = [] - - self.next_id_ = 0 - - def register (self, target): - """ Registers a new virtual target. Checks if there's already registered target, with the same - name, type, project and subvariant properties, and also with the same sources - and equal action. If such target is found it is retured and 'target' is not registered. - Otherwise, 'target' is registered and returned. - """ - if target.path(): - signature = target.path() + "-" + target.name() - else: - signature = "-" + target.name() - - result = None - if not self.cache_.has_key (signature): - self.cache_ [signature] = [] - - for t in self.cache_ [signature]: - a1 = t.action () - a2 = target.action () - - # TODO: why are we checking for not result? - if not result: - if not a1 and not a2: - result = t - else: - if a1 and a2 and a1.action_name () == a2.action_name () and a1.sources () == a2.sources (): - ps1 = a1.properties () - ps2 = a2.properties () - p1 = ps1.base () + ps1.free () +\ - b2.util.set.difference(ps1.dependency(), ps1.incidental()) - p2 = ps2.base () + ps2.free () +\ - b2.util.set.difference(ps2.dependency(), ps2.incidental()) - if p1 == p2: - result = t - - if not result: - self.cache_ [signature].append (target) - result = target - - # TODO: Don't append if we found pre-existing target? - self.recent_targets_.append(result) - self.all_targets_.append(result) - - return result - - def from_file (self, file, file_location, project): - """ Creates a virtual target with appropriate name and type from 'file'. - If a target with that name in that project was already created, returns that already - created target. - TODO: more correct way would be to compute path to the file, based on name and source location - for the project, and use that path to determine if the target was already created. - TODO: passing project with all virtual targets starts to be annoying. - """ - # Check if we've created a target corresponding to this file. - path = os.path.join(os.getcwd(), file_location, file) - path = os.path.normpath(path) - - if self.files_.has_key (path): - return self.files_ [path] - - file_type = b2.build.type.type (file) - - result = FileTarget (file, file_type, project, - None, file_location) - self.files_ [path] = result - - return result - - def recent_targets(self): - """Each target returned by 'register' is added to a list of - 'recent-target', returned by this function. So, this allows - us to find all targets created when building a given main - target, even if the target.""" - - return self.recent_targets_ - - def clear_recent_targets(self): - self.recent_targets_ = [] - - def all_targets(self): - # Returns all virtual targets ever created - return self.all_targets_ - - # Returns all targets from 'targets' with types - # equal to 'type' or derived from it. - def select_by_type(self, type, targets): - return [t for t in targets if b2.build.type.is_sybtype(t.type(), type)] - - def register_actual_name (self, actual_name, virtual_target): - if self.actual_.has_key (actual_name): - cs1 = self.actual_ [actual_name].creating_subvariant () - cs2 = virtual_target.creating_subvariant () - cmt1 = cs1.main_target () - cmt2 = cs2.main_target () - - action1 = self.actual_ [actual_name].action () - action2 = virtual_target.action () - - properties_added = [] - properties_removed = [] - if action1 and action2: - p1 = action1.properties () - p1 = p1.raw () - p2 = action2.properties () - p2 = p2.raw () - - properties_removed = set.difference (p1, p2) - if not properties_removed: properties_removed = "none" - - properties_added = set.difference (p2, p1) - if not properties_added: properties_added = "none" - - # FIXME: Revive printing of real location. - get_manager().errors()( - "Duplicate name of actual target: '%s'\n" - "previous virtual target '%s'\n" - "created from '%s'\n" - "another virtual target '%s'\n" - "created from '%s'\n" - "added properties: '%s'\n" - "removed properties: '%s'\n" - % (actual_name, - self.actual_ [actual_name], "loc", #cmt1.location (), - virtual_target, - "loc", #cmt2.location (), - properties_added, properties_removed)) - - else: - self.actual_ [actual_name] = virtual_target - - - def add_suffix (self, specified_name, file_type, prop_set): - """ Appends the suffix appropriate to 'type/property_set' combination - to the specified name and returns the result. - """ - suffix = b2.build.type.generated_target_suffix (file_type, prop_set) - - if suffix: - return specified_name + '.' + suffix - - else: - return specified_name - -class VirtualTarget: - """ Potential target. It can be converted into jam target and used in - building, if needed. However, it can be also dropped, which allows - to search for different transformation and select only one. - name: name of this target. - project: project to which this target belongs. - """ - def __init__ (self, name, project): - self.name_ = name - self.project_ = project - self.dependencies_ = [] - self.always_ = False - - # Caches if dapendencies for scanners have already been set. - self.made_ = {} - - def manager(self): - return self.project_.manager() - - def virtual_targets(self): - return self.manager().virtual_targets() - - def name (self): - """ Name of this target. - """ - return self.name_ - - def project (self): - """ Project of this target. - """ - return self.project_ - - def depends (self, d): - """ Adds additional instances of 'VirtualTarget' that this - one depends on. - """ - self.dependencies_ = unique (self.dependencies_ + d).sort () - - def dependencies (self): - return self.dependencies_ - - def always(self): - self.always_ = True - - 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 self.always_: - bjam.call("ALWAYS", actual_name) - - 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 - -# private: (overridables) - - def actualize_action (self, target): - """ Sets up build actions for 'target'. Should call appropriate rules - and set target variables. - """ - raise BaseException ("method should be defined in derived classes") - - def actualize_location (self, target): - """ Sets up variables on 'target' which specify its location. - """ - raise BaseException ("method should be defined in derived classes") - - def path (self): - """ If the target is generated one, returns the path where it will be - generated. Otherwise, returns empty list. - """ - raise BaseException ("method should be defined in derived classes") - - def actual_name (self): - """ Return that actual target name that should be used - (for the case where no scanner is involved) - """ - raise BaseException ("method should be defined in derived classes") - - -class AbstractFileTarget (VirtualTarget): - """ Target which correspond to a file. The exact mapping for file - is not yet specified in this class. (TODO: Actually, the class name - could be better...) - - May be a source file (when no action is specified), or - derived file (otherwise). - - The target's grist is concatenation of project's location, - properties of action (for derived files), and, optionally, - value identifying the main target. - - exact: If non-empty, the name is exactly the name - created file should have. Otherwise, the '__init__' - method will add suffix obtained from 'type' by - calling 'type.generated-target-suffix'. - - type: optional type of this target. - """ - def __init__ (self, name, type, project, action = None, exact=False): - VirtualTarget.__init__ (self, name, project) - - self.type_ = type - - self.action_ = action - self.exact_ = exact - - if action: - action.add_targets ([self]) - - if self.type and not exact: - self.__adjust_name (name) - - - self.actual_name_ = None - self.path_ = None - self.intermediate_ = False - self.creating_subvariant_ = None - - # True if this is a root target. - self.root_ = False - - def type (self): - return self.type_ - - def set_path (self, path): - """ Sets the path. When generating target name, it will override any path - computation from properties. - """ - self.path_ = path - - def action (self): - """ Returns the action. - """ - return self.action_ - - def root (self, set = None): - """ Sets/gets the 'root' flag. Target is root is it directly correspods to some - variant of a main target. - """ - if set: - self.root_ = True - return self.root_ - - def creating_subvariant (self, s = None): - """ Gets or sets the subvariant which created this target. Subvariant - is set when target is brought into existance, and is never changed - after that. In particual, if target is shared by subvariant, only - the first is stored. - s: If specified, specified the value to set, - which should be instance of 'subvariant' class. - """ - if s and not self.creating_subvariant (): - if self.creating_subvariant (): - raise BaseException ("Attempt to change 'dg'") - - else: - self.creating_subvariant_ = s - - return self.creating_subvariant_ - - def actualize_action (self, target): - if self.action_: - self.action_.actualize () - - # Return a human-readable representation of this target - # - # If this target has an action, that's: - # - # { <action-name>-<self.name>.<self.type> <action-sources>... } - # - # otherwise, it's: - # - # { <self.name>.<self.type> } - # - def str(self): - a = self.action() - - name_dot_type = self.name_ + "." + self.type_ - - if a: - action_name = a.action_name() - ss = [ s.str() for s in a.sources()] - - return "{ %s-%s %s}" % (action_name, name_dot_type, str(ss)) - else: - return "{ " + name_dot_type + " }" - -# private: - - def actual_name (self): - if not self.actual_name_: - self.actual_name_ = '<' + self.grist() + '>' + self.name_ - - return self.actual_name_ - - def grist (self): - """Helper to 'actual_name', above. Compute unique prefix used to distinguish - this target from other targets with the same name which create different - file. - """ - # Depending on target, there may be different approaches to generating - # unique prefixes. We'll generate prefixes in the form - # <one letter approach code> <the actual prefix> - path = self.path () - - if path: - # The target will be generated to a known path. Just use the path - # for identification, since path is as unique as it can get. - return 'p' + path - - else: - # File is either source, which will be searched for, or is not a file at - # all. Use the location of project for distinguishing. - project_location = self.project_.get ('location') - path_components = b2.util.path.split(project_location) - location_grist = '!'.join (path_components) - - if self.action_: - ps = self.action_.properties () - property_grist = ps.as_path () - # 'property_grist' can be empty when 'ps' is an empty - # property set. - if property_grist: - location_grist = location_grist + '/' + property_grist - - return 'l' + location_grist - - def __adjust_name(self, specified_name): - """Given the target name specified in constructor, returns the - name which should be really used, by looking at the <tag> properties. - The tag properties come in two flavour: - - <tag>value, - - <tag>@rule-name - In the first case, value is just added to name - In the second case, the specified rule is called with specified name, - target type and properties and should return the new name. - If not <tag> property is specified, or the rule specified by - <tag> returns nothing, returns the result of calling - virtual-target.add-suffix""" - - if self.action_: - ps = self.action_.properties() - else: - ps = property_set.empty() - - # FIXME: I'm not sure how this is used, need to check with - # Rene to figure out how to implement - #~ We add ourselves to the properties so that any tag rule can get - #~ more direct information about the target than just that available - #~ through the properties. This is useful in implementing - #~ name changes based on the sources of the target. For example to - #~ make unique names of object files based on the source file. - #~ --grafik - #ps = property_set.create(ps.raw() + ["<target>%s" % "XXXX"]) - #ps = [ property-set.create [ $(ps).raw ] <target>$(__name__) ] ; - - tag = ps.get("<tag>") - - if tag: - - if len(tag) > 1: - get_manager().errors()( - """<tag>@rulename is present but is not the only <tag> feature""") - - tag = tag[0] - if callable(tag): - self.name_ = tag(specified_name, self.type_, ps) - else: - if not tag[0] == '@': - self.manager_.errors()("""The value of the <tag> feature must be '@rule-nane'""") - - exported_ps = b2.util.value_to_jam(ps, methods=True) - self.name_ = b2.util.call_jam_function( - tag[1:], specified_name, self.type_, exported_ps) - if self.name_: - self.name_ = self.name_[0] - - # If there's no tag or the tag rule returned nothing. - if not tag or not self.name_: - self.name_ = add_prefix_and_suffix(specified_name, self.type_, ps) - - def actualize_no_scanner(self): - name = self.actual_name() - - # Do anything only on the first invocation - if not self.made_: - self.made_[name] = True - - if self.action_: - # For non-derived target, we don't care if there - # are several virtual targets that refer to the same name. - # One case when this is unavoidable is when file name is - # main.cpp and two targets have types CPP (for compiling) - # and MOCCABLE_CPP (for convertion to H via Qt tools). - self.virtual_targets().register_actual_name(name, self) - - for i in self.dependencies_: - self.manager_.engine().add_dependency(name, i.actualize()) - - self.actualize_location(name) - self.actualize_action(name) - - return name - -@bjam_signature((["specified_name"], ["type"], ["property_set"])) -def add_prefix_and_suffix(specified_name, type, property_set): - """Appends the suffix appropriate to 'type/property-set' combination - to the specified name and returns the result.""" - - property_set = b2.util.jam_to_value_maybe(property_set) - - suffix = "" - if type: - suffix = b2.build.type.generated_target_suffix(type, property_set) - - # Handle suffixes for which no leading dot is desired. Those are - # specified by enclosing them in <...>. Needed by python so it - # can create "_d.so" extensions, for example. - if get_grist(suffix): - suffix = ungrist(suffix) - elif suffix: - suffix = "." + suffix - - prefix = "" - if type: - prefix = b2.build.type.generated_target_prefix(type, property_set) - - if specified_name.startswith(prefix): - prefix = "" - - if not prefix: - prefix = "" - if not suffix: - suffix = "" - return prefix + specified_name + suffix - - -class FileTarget (AbstractFileTarget): - """ File target with explicitly known location. - - The file path is determined as - - value passed to the 'set_path' method, if any - - for derived files, project's build dir, joined with components - that describe action's properties. If the free properties - are not equal to the project's reference properties - an element with name of main target is added. - - for source files, project's source dir - - The file suffix is - - the value passed to the 'suffix' method, if any, or - - the suffix which correspond to the target's type. - """ - def __init__ (self, name, type, project, action = None, path=None, exact=False): - AbstractFileTarget.__init__ (self, name, type, project, action, exact) - - self.path_ = path - - def __str__(self): - if self.type_: - return self.name_ + "." + self.type_ - else: - return self.name_ - - def clone_with_different_type(self, new_type): - return FileTarget(self.name_, new_type, self.project_, - self.action_, self.path_, exact=True) - - def actualize_location (self, target): - engine = self.project_.manager_.engine () - - if self.action_: - # This is a derived file. - path = self.path () - engine.set_target_variable (target, 'LOCATE', path) - - # Make sure the path exists. - engine.add_dependency (target, path) - common.mkdir(engine, path) - - # It's possible that the target name includes a directory - # too, for example when installing headers. Create that - # directory. - d = os.path.dirname(get_value(target)) - if d: - d = os.path.join(path, d) - engine.add_dependency(target, d) - common.mkdir(engine, d) - - # For real file target, we create a fake target that - # depends on the real target. This allows to run - # - # bjam hello.o - # - # without trying to guess the name of the real target. - # Note the that target has no directory name, and a special - # grist <e>. - # - # First, that means that "bjam hello.o" will build all - # known hello.o targets. - # Second, the <e> grist makes sure this target won't be confused - # with other targets, for example, if we have subdir 'test' - # with target 'test' in it that includes 'test.o' file, - # then the target for directory will be just 'test' the target - # for test.o will be <ptest/bin/gcc/debug>test.o and the target - # we create below will be <e>test.o - engine.add_dependency("<e>%s" % get_value(target), target) - - # Allow bjam <path-to-file>/<file> to work. This won't catch all - # possible ways to refer to the path (relative/absolute, extra ".", - # various "..", but should help in obvious cases. - engine.add_dependency("<e>%s" % (os.path.join(path, get_value(target))), target) - - else: - # This is a source file. - engine.set_target_variable (target, 'SEARCH', self.project_.get ('source-location')) - - - def path (self): - """ Returns the directory for this target. - """ - if not self.path_: - if self.action_: - p = self.action_.properties () - (target_path, relative_to_build_dir) = p.target_path () - - if relative_to_build_dir: - # Indicates that the path is relative to - # build dir. - target_path = os.path.join (self.project_.build_dir (), target_path) - - # Store the computed path, so that it's not recomputed - # any more - self.path_ = target_path - - return self.path_ - - -class NotFileTarget(AbstractFileTarget): - - def __init__(self, name, project, action): - AbstractFileTarget.__init__(self, name, None, project, action) - - def path(self): - """Returns nothing, to indicate that target path is not known.""" - return None - - def actualize_location(self, target): - bjam.call("NOTFILE", target) - bjam.call("ALWAYS", target) - bjam.call("NOUPDATE", target) - - -class Action: - """ Class which represents an action. - Both 'targets' and 'sources' should list instances of 'VirtualTarget'. - Action name should name a rule with this prototype - rule action_name ( targets + : sources * : properties * ) - Targets and sources are passed as actual jam targets. The rule may - not establish dependency relationship, but should do everything else. - """ - def __init__ (self, manager, sources, action_name, prop_set): - assert(isinstance(prop_set, property_set.PropertySet)) - assert type(sources) == types.ListType - self.sources_ = sources - self.action_name_ = action_name - if not prop_set: - prop_set = property_set.empty() - self.properties_ = prop_set - if not all(isinstance(v, VirtualTarget) for v in prop_set.get('implicit-dependency')): - import pdb - pdb.set_trace() - - self.manager_ = manager - self.engine_ = self.manager_.engine () - self.targets_ = [] - - # Indicates whether this has been actualized or not. - self.actualized_ = False - - self.dependency_only_sources_ = [] - self.actual_sources_ = [] - - - def add_targets (self, targets): - self.targets_ += targets - - - def replace_targets (old_targets, new_targets): - self.targets_ = [t for t in targets if not t in old_targets] + new_targets - - def targets (self): - return self.targets_ - - def sources (self): - return self.sources_ - - def action_name (self): - return self.action_name_ - - def properties (self): - return self.properties_ - - def actualize (self): - """ Generates actual build instructions. - """ - if self.actualized_: - return - - self.actualized_ = True - - ps = self.properties () - properties = self.adjust_properties (ps) - - - actual_targets = [] - - for i in self.targets (): - actual_targets.append (i.actualize ()) - - self.actualize_sources (self.sources (), properties) - - self.engine_.add_dependency (actual_targets, self.actual_sources_ + self.dependency_only_sources_) - - # This works around a bug with -j and actions that - # produce multiple target, where: - # - dependency on the first output is found, and - # the action is started - # - dependency on the second output is found, and - # bjam noticed that command is already running - # - instead of waiting for the command, dependents - # of the second targets are immediately updated. - if len(actual_targets) > 1: - bjam.call("INCLUDES", actual_targets, actual_targets) - - # FIXME: check the comment below. Was self.action_name_ [1] - # Action name can include additional argument to rule, which should not - # be passed to 'set-target-variables' - # FIXME: breaking circular dependency - import toolset - toolset.set_target_variables (self.manager_, self.action_name_, actual_targets, properties) - - engine = self.manager_.engine () - - # FIXME: this is supposed to help --out-xml option, but we don't - # implement that now, and anyway, we should handle it in Python, - # not but putting variables on bjam-level targets. - bjam.call("set-target-variable", actual_targets, ".action", repr(self)) - - self.manager_.engine ().set_update_action (self.action_name_, actual_targets, self.actual_sources_, - properties) - - # Since we set up creating action here, we also set up - # action for cleaning up - self.manager_.engine ().set_update_action ('common.Clean', 'clean-all', - actual_targets) - - return actual_targets - - def actualize_source_type (self, sources, prop_set): - """ Helper for 'actualize_sources'. - For each passed source, actualizes it with the appropriate scanner. - Returns the actualized virtual targets. - """ - result = [] - for i in sources: - scanner = None - -# FIXME: what's this? -# if isinstance (i, str): -# i = self.manager_.get_object (i) - - if i.type (): - scanner = b2.build.type.get_scanner (i.type (), prop_set) - - r = i.actualize (scanner) - result.append (r) - - return result - - def actualize_sources (self, sources, prop_set): - """ Creates actual jam targets for sources. Initializes two member - variables: - 'self.actual_sources_' -- sources which are passed to updating action - 'self.dependency_only_sources_' -- sources which are made dependencies, but - are not used otherwise. - - New values will be *appended* to the variables. They may be non-empty, - if caller wants it. - """ - dependencies = self.properties_.get ('<dependency>') - - self.dependency_only_sources_ += self.actualize_source_type (dependencies, prop_set) - self.actual_sources_ += self.actualize_source_type (sources, prop_set) - - # This is used to help bjam find dependencies in generated headers - # in other main targets. - # Say: - # - # make a.h : ....... ; - # exe hello : hello.cpp : <implicit-dependency>a.h ; - # - # However, for bjam to find the dependency the generated target must - # be actualized (i.e. have the jam target). In the above case, - # if we're building just hello ("bjam hello"), 'a.h' won't be - # actualized unless we do it here. - implicit = self.properties_.get("<implicit-dependency>") - - for i in implicit: - i.actualize() - - def adjust_properties (self, prop_set): - """ Determines real properties when trying building with 'properties'. - This is last chance to fix properties, for example to adjust includes - to get generated headers correctly. Default implementation returns - its argument. - """ - return prop_set - - -class NullAction (Action): - """ Action class which does nothing --- it produces the targets with - specific properties out of nowhere. It's needed to distinguish virtual - targets with different properties that are known to exist, and have no - actions which create them. - """ - def __init__ (self, manager, prop_set): - Action.__init__ (self, manager, [], None, prop_set) - - def actualize (self): - if not self.actualized_: - self.actualized_ = True - - for i in self.targets (): - i.actualize () - -class NonScanningAction(Action): - """Class which acts exactly like 'action', except that the sources - are not scanned for dependencies.""" - - def __init__(self, sources, action_name, property_set): - #FIXME: should the manager parameter of Action.__init__ - #be removed? -- Steven Watanabe - Action.__init__(self, b2.manager.get_manager(), sources, action_name, property_set) - - def actualize_source_type(self, sources, property_set): - - result = [] - for s in sources: - result.append(s.actualize()) - return result - -def traverse (target, include_roots = False, include_sources = False): - """ Traverses the dependency graph of 'target' and return all targets that will - be created before this one is created. If root of some dependency graph is - found during traversal, it's either included or not, dependencing of the - value of 'include_roots'. In either case, sources of root are not traversed. - """ - result = [] - - if target.action (): - action = target.action () - - # This includes 'target' as well - result += action.targets () - - for t in action.sources (): - - # FIXME: - # TODO: see comment in Manager.register_object () - #if not isinstance (t, VirtualTarget): - # t = target.project_.manager_.get_object (t) - - if not t.root (): - result += traverse (t, include_roots, include_sources) - - elif include_roots: - result.append (t) - - elif include_sources: - result.append (target) - - return result - -def clone_action (action, new_project, new_action_name, new_properties): - """Takes an 'action' instances and creates new instance of it - and all produced target. The rule-name and properties are set - to 'new-rule-name' and 'new-properties', if those are specified. - Returns the cloned action.""" - - if not new_action_name: - new_action_name = action.action_name() - - if not new_properties: - new_properties = action.properties() - - cloned_action = action.__class__(action.manager_, action.sources(), new_action_name, - new_properties) - - cloned_targets = [] - for target in action.targets(): - - n = target.name() - # Don't modify the name of the produced targets. Strip the directory f - cloned_target = FileTarget(n, target.type(), new_project, - cloned_action, exact=True) - - d = target.dependencies() - if d: - cloned_target.depends(d) - cloned_target.root(target.root()) - cloned_target.creating_subvariant(target.creating_subvariant()) - - cloned_targets.append(cloned_target) - - return cloned_action - -class Subvariant: - - 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: - self.other_dg_.append(d.creating_subvariant ()) - - self.other_dg_ = unique (self.other_dg_) - - self.implicit_includes_cache_ = {} - self.target_directories_ = None - - def main_target (self): - return self.main_target_ - - def created_targets (self): - return self.created_targets_ - - def requested_properties (self): - return self.properties_ - - def build_properties (self): - return self.build_properties_ - - def sources_usage_requirements (self): - return self.sources_usage_requirements_ - - def set_usage_requirements (self, usage_requirements): - self.usage_requirements_ = usage_requirements - - def usage_requirements (self): - return self.usage_requirements_ - - def all_referenced_targets(self, result): - """Returns all targets referenced by this subvariant, - either directly or indirectly, and either as sources, - or as dependency properties. Targets referred with - dependency property are returned a properties, not targets.""" - - # Find directly referenced targets. - deps = self.build_properties().dependency() - all_targets = self.sources_ + deps - - # Find other subvariants. - r = [] - for e in all_targets: - if not e in result: - result.add(e) - if isinstance(e, property.Property): - t = e.value() - else: - t = e - - # FIXME: how can this be? - cs = t.creating_subvariant() - if cs: - r.append(cs) - r = unique(r) - for s in r: - if s != self: - s.all_referenced_targets(result) - - - def implicit_includes (self, feature, target_type): - """ Returns the properties which specify implicit include paths to - generated headers. This traverses all targets in this subvariant, - and subvariants referred by <implcit-dependecy>properties. - For all targets which are of type 'target-type' (or for all targets, - if 'target_type' is not specified), the result will contain - <$(feature)>path-to-that-target. - """ - - if not target_type: - key = feature - else: - key = feature + "-" + target_type - - - result = self.implicit_includes_cache_.get(key) - if not result: - target_paths = self.all_target_directories(target_type) - target_paths = unique(target_paths) - result = ["<%s>%s" % (feature, p) for p in target_paths] - self.implicit_includes_cache_[key] = result - - return result - - def all_target_directories(self, target_type = None): - # TODO: does not appear to use target_type in deciding - # if we've computed this already. - if not self.target_directories_: - self.target_directories_ = self.compute_target_directories(target_type) - return self.target_directories_ - - def compute_target_directories(self, target_type=None): - result = [] - for t in self.created_targets(): - if not target_type or b2.build.type.is_derived(t.type(), target_type): - result.append(t.path()) - - for d in self.other_dg_: - result.extend(d.all_target_directories(target_type)) - - result = unique(result) - return result |