From: jurko.gospodnetic_at_[hidden]
Date: 2008-01-05 13:13:11
Author: jurko
Date: 2008-01-05 13:13:10 EST (Sat, 05 Jan 2008)
New Revision: 42489
URL: http://svn.boost.org/trac/boost/changeset/42489
Log:
Removed or simplified some import calls. Comment updates. Minor stylistic changes.
Text files modified:
trunk/tools/build/v2/build/generators.jam | 526 +++++++++++-----------
trunk/tools/build/v2/build/modifiers.jam | 8
trunk/tools/build/v2/build/targets.jam | 887 ++++++++++++++++++++-------------------
trunk/tools/build/v2/build/type.jam | 260 ++++++-----
trunk/tools/build/v2/build/virtual-target.jam | 470 +++++++++++----------
trunk/tools/build/v2/tools/package.jam | 2
trunk/tools/build/v2/tools/stage.jam | 335 +++++++-------
7 files changed, 1266 insertions(+), 1222 deletions(-)
Modified: trunk/tools/build/v2/build/generators.jam
==============================================================================
--- trunk/tools/build/v2/build/generators.jam (original)
+++ trunk/tools/build/v2/build/generators.jam 2008-01-05 13:13:10 EST (Sat, 05 Jan 2008)
@@ -5,22 +5,23 @@
# (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.
+# 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.
+# 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.
#
-# If the generator has collected all the targets it needs, it creates targets
+# 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.
#
@@ -31,7 +32,7 @@
# 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
+# 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
@@ -42,7 +43,7 @@
# '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 "class" : is-a new ;
+import "class" : new ;
import container ;
import utility : str equal ;
import set sequence ;
@@ -50,8 +51,8 @@
import virtual-target ;
import property-set ;
-if "--debug-generators" in [ modules.peek : ARGV ]
-{
+if "--debug-generators" in [ modules.peek : ARGV ]
+{
.debug = true ;
}
@@ -61,9 +62,9 @@
local rule generators.dout ( message * )
{
if $(.debug)
- {
+ {
ECHO [ sequence.transform utility.str : $(message) ] ;
- }
+ }
}
@@ -92,7 +93,7 @@
}
# Creates a generator
-class generator
+class generator
{
import generators ;
import assert ;
@@ -107,41 +108,41 @@
import virtual-target ;
import "class" : new ;
import property ;
-
+
EXPORT class_at_generator : indent increase-indent decrease-indent generators.dout ;
-
- rule __init__ (
+
+ rule __init__ (
id # identifies the generator - should be name of 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 * # types that this generator can handle. If
# empty, the generator can consume anything.
-
- : target-types-and-names +
+
+ : 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 *
)
- {
+ {
self.id = $(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
+ # 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)".
@@ -150,14 +151,14 @@
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) ;
@@ -171,14 +172,14 @@
# 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.
+ # 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
+ # 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?
@@ -186,8 +187,8 @@
{
return $(self.requirements) ;
}
-
- # Returns a true value if the generator can be run with the specified
+
+ # Returns a true value if the generator can be run with the specified
# properties.
rule match-rank ( property-set-to-match )
{
@@ -196,7 +197,7 @@
# (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)
{
@@ -207,11 +208,11 @@
else
{
feature-requirements += $(r) ;
- }
+ }
}
local properties-to-match = [ $(property-set-to-match).raw ] ;
- if $(property-requirements) in $(properties-to-match)
+ if $(property-requirements) in $(properties-to-match)
&& $(feature-requirements) in $(properties-to-match:G)
{
return true ;
@@ -221,7 +222,7 @@
return ;
}
}
-
+
# Returns another generator which differers from $(self) in
# - id
# - value to <toolset> feature in properties
@@ -229,14 +230,14 @@
{
return [ new $(__class__) $(new-id) $(self.composing)
: $(self.source-types)
- : $(self.target-types-and-names)
+ : $(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)
] ;
}
-
+
# 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.
@@ -253,37 +254,37 @@
else
{
target-types += $(t) ;
- }
+ }
}
-
+
return [ new $(__class__) $(self.id) $(self.composing)
: $(self.source-types)
- : $(target-types)
+ : $(target-types)
: $(self.requirements)
] ;
}
-
+
# Tries to invoke this generator on the given sources. Returns a
# list of generated targets (instances of 'virtual-target').
# 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 ? # Determines the name of 'name' attribute for
+ name ? # Determines the name of 'name' attribute for
# all generated targets. See 'generated-targets' method.
: property-set # Desired properties for generated targets.
: sources + # Source targets.
)
- {
+ {
generators.dout [ indent ] " ** generator" $(self.id) ;
generators.dout [ indent ] " multiple:" $(mutliple) ;
- generators.dout [ indent ] " composing:" $(self.composing) ;
-
+ generators.dout [ indent ] " composing:" $(self.composing) ;
+
if ! $(self.composing) && $(sources[2]) && $(self.source-types[2])
{
errors.error "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
@@ -292,43 +293,43 @@
# 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
+ # transofrmation CPP -> OBJ -> STATIC_LIB -> RSP -> EXE won't be allowed
# (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't 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 ;
+ : $(property-set) : $(sources) : consumed bypassed ;
}
else
- {
- convert-to-consumable-types $(project) $(name) :
- $(property-set) : $(sources)
+ {
+ convert-to-consumable-types $(project) $(name) :
+ $(property-set) : $(sources)
:
: consumed bypassed ;
}
-
+
local result ;
- if $(consumed)
- {
- result = [ construct-result $(consumed) : $(project) $(name)
+ if $(consumed)
+ {
+ result = [ construct-result $(consumed) : $(project) $(name)
: $(property-set) ] ;
}
-
-
+
+
if $(result)
{
generators.dout [ indent ] " SUCCESS: " $(result) ;
@@ -338,18 +339,18 @@
generators.dout [ indent ] " FAILURE" ;
}
generators.dout ;
- return $(result) ;
+ return $(result) ;
}
- # Constructs the dependency graph that will be returned by this
+ # Constructs the dependency graph that will be returned by this
# generator
- rule construct-result (
+ rule construct-result (
consumed + # Already prepared list of consumable targets
- # If generator requires several source files will contain
+ # 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[1])
- : project name ?
+ # Otherwise, might contain several targets with the type of
+ # $(self.source-types[1])
+ : project name ?
: property-set # Properties to be used for all actions create here
)
{
@@ -358,21 +359,21 @@
if ! $(self.source-types[2]) && ! $(self.composing)
{
for local r in $(consumed)
- {
+ {
result += [ generated-targets $(r) : $(property-set) : $(project) $(name) ] ; #(targets) ;
}
}
else
{
- if $(consumed)
+ if $(consumed)
{
- result += [ generated-targets $(consumed) : $(property-set)
+ result += [ generated-targets $(consumed) : $(property-set)
: $(project) $(name) ] ;
- }
+ }
}
return $(result) ;
}
-
+
# Determine the name of the produced target from the
# names of the sources.
rule determine-output-name ( sources + )
@@ -387,7 +388,7 @@
# dot. In the second case -- no sure, but for now take
# the part till the last dot too.
name = [ utility.basename [ $(sources[1]).name ] ] ;
-
+
for local s in $(sources[2])
{
local n2 = [ utility.basename [ $(s).name ] ] ;
@@ -396,23 +397,23 @@
error "$(self.id): source targets have different names: cannot determine target name" ;
}
}
-
+
# Names of sources might include directory. We should strip it.
name = $(name:D=) ;
-
+
return $(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
+ #
+ # 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
+ # 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
@@ -421,7 +422,7 @@
# 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
+ # in make. It's a way to produce target which name is different for name of
# source.
rule generated-targets ( sources + : property-set : project name ? )
{
@@ -429,83 +430,83 @@
{
name = [ determine-output-name $(sources) ] ;
}
-
+
# Assign an action for each target
local action = [ action-class ] ;
- local a = [ class.new $(action) $(sources) : $(self.id) :
+ local a = [ class.new $(action) $(sources) : $(self.id) :
$(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)
- {
+ for local t in $(self.target-types)
+ {
local generated-name = $(pre[1])$(name)$(post[1]) ;
pre = $(pre[2-]) ;
post = $(post[2-]) ;
-
- targets += [ class.new file-target $(generated-name)
+
+ targets += [ class.new file-target $(generated-name)
: $(t) : $(project) : $(a) ] ;
- }
-
+ }
+
return [ sequence.transform virtual-target.register : $(targets) ] ;
- }
-
+ }
+
# 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.
- rule convert-to-consumable-types ( project name ? :
- property-set : sources +
+ rule convert-to-consumable-types ( project name ? :
+ property-set : sources +
: only-one ? # convert 'source' to only one of source types
# if there's more that one possibility, report an
- # error
- : consumed-var # name of variable which recieves all targets which
- # can be consumed.
- bypassed-var # name variable which recieves all targets which
- # cannot be consumed
+ # error
+ : consumed-var # name of variable which recieves all targets which
+ # can be consumed.
+ bypassed-var # name variable which recieves all targets which
+ # cannot be consumed
)
- {
+ {
# We're likely to be passed 'consumed' and 'bypassed'
# var names. Use "_" to avoid name conflicts.
local _consumed ;
local _bypassed ;
- local missing-types ;
+ local missing-types ;
if $(sources[2])
{
- # Don't know how to handle several sources yet. Just try
+ # Don't 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)
+ 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 consuned/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's no need to rerun it on targets of different types.
-
+
# NOTE: ignoring usage requirements
for local t in $(transformed[2-])
{
@@ -517,34 +518,34 @@
{
_bypassed += $(t) ;
}
- }
- }
-
- _consumed = [ sequence.unique $(_consumed) ] ;
+ }
+ }
+
+ _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
+
+ # 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.
-
+ # 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) ] ;
-
-
+
+
$(consumed-var) += $(_consumed) ;
$(bypassed-var) += $(_bypassed) ;
}
-
+
# Converts several files to consumable types.
rule convert-multiple-sources-to-consumable-types
( project : property-set : sources * : consumed-var bypassed-var )
@@ -562,23 +563,23 @@
{
generators.dout [ indent ] " failed to convert " $(source) ;
}
- $(consumed-var) += $(_c) ;
+ $(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 right type already)
- if $(real-source-type) = $(st) ||
+ if $(real-source-type) = $(st) ||
[ type.is-derived $(real-source-type) $(st) ]
{
$(consumed-var) += $(source) ;
@@ -587,16 +588,16 @@
{
$(missing-types-var) += $(st) ;
}
- }
+ }
}
-
-
- # Returns the class to be used to actions. Default implementation
+
+
+ # Returns the class to be used to actions. Default implementation
# returns "action".
rule action-class ( )
{
return "action" ;
- }
+ }
}
import errors : error ;
@@ -607,24 +608,24 @@
rule register ( g )
{
.generators += $(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 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 the
# normal $(id:S=) won't generate the right toolset name.
# e.g. if id = gcc.compile.c++, then
@@ -640,7 +641,7 @@
}
.generators-for-toolset.$(base) += $(g) ;
}
-
+
# Creates new instance of the 'generator' class and registers it.
# Retursn the creates instance.
# Rationale: the instance is returned so that it's possible to first register
@@ -650,7 +651,7 @@
{
local g = [ new generator $(id) : $(source-types) : $(target-types)
: $(requirements) ] ;
- register $(g) ;
+ register $(g) ;
return $(g) ;
}
@@ -658,7 +659,7 @@
# registers it.
rule register-composing ( id : source-types * : target-types + : requirements * )
{
- local g = [ new generator $(id) true : $(source-types)
+ local g = [ new generator $(id) true : $(source-types)
: $(target-types) : $(requirements) ] ;
register $(g) ;
return $(g) ;
@@ -682,12 +683,12 @@
# running any of them.
rule override ( overrider-id : overridee-id )
{
- .override.$(overrider-id) += $(overridee-id) ;
+ .override.$(overrider-id) += $(overridee-id) ;
}
-
+
# Set if results of the current generators search are going to be cached
# This means no futher attempts to cache generators search should be
# made.
@@ -704,23 +705,23 @@
local generators ;
local t = [ type.all-bases $(target-type) ] ;
-
+
local result ;
- # 't' is the list of types which are not yet processed
+ # 't' is the list of types which are not yet processed
while $(t)
{
- # Find all generators for current type.
+ # Find all generators for current type.
# Unlike 'find-viable-generators' we don't care about 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
@@ -730,10 +731,10 @@
# This will terminate outer loop.
t = ;
}
-
- for local source-type in [ $(g).source-types ]
+
+ for local source-type in [ $(g).source-types ]
{
- if ! $(source-type) in $(result)
+ if ! $(source-type) in $(result)
{
# If generator accepts 'source-type' it
# will happily accept any type derived from it
@@ -741,19 +742,19 @@
for local n in $(all)
{
if ! $(n) in $(result)
- {
+ {
t += $(n) ;
result += $(n) ;
- }
- }
- }
- }
- }
- }
-
+ }
+ }
+ }
+ }
+ }
+ }
+
result = [ sequence.unique $(result) ] ;
-
- return $(result) ;
+
+ return $(result) ;
}
# Helper rule, caches the result of 'viable-source-types-real'.
@@ -769,18 +770,18 @@
}
$(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)
-rule viable-source-types-for-generator-real ( generator )
-{
+rule viable-source-types-for-generator-real ( generator )
+{
local source-types = [ $(generator).source-types ] ;
if ! $(source-types)
{
@@ -792,21 +793,21 @@
return * ;
}
else
- {
+ {
local result ;
for local s in $(source-types)
{
- result += [ type.all-derived $(s) ]
+ result += [ type.all-derived $(s) ]
[ generators.viable-source-types $(s) ] ;
}
- result = [ sequence.unique $(result) ] ;
+ result = [ sequence.unique $(result) ] ;
if * in $(result)
{
result = * ;
- }
+ }
return $(result) ;
- }
-}
+ }
+}
# Helper rule, caches the result of 'viable-source-types-for-genrator'.
local rule viable-source-types-for-generator ( generator )
@@ -819,19 +820,19 @@
{
v = none ;
}
- $(key) = $(v) ;
+ $(key) = $(v) ;
}
-
+
if $($(key)) != none
{
return $($(key)) ;
- }
+ }
}
# Returns usage requirements + list of created targets
-local rule try-one-generator-really ( project name ? : generator :
+local rule try-one-generator-really ( project name ? : generator :
target-type : property-set : sources * )
{
local targets =
@@ -839,16 +840,16 @@
: $(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]) ;
@@ -859,15 +860,14 @@
usage-requirements = [ property-set.empty ] ;
}
}
-
+
generators.dout [ indent ] " generator" [ $(generator).id ] " spawned " ;
- generators.dout [ indent ] " " $(targets) ;
+ generators.dout [ indent ] " " $(targets) ;
if $(usage-requirements)
{
generators.dout [ indent ] " with usage requirements:" $(x) ;
}
-
-
+
if $(success)
{
return $(usage-requirements) $(targets) ;
@@ -877,37 +877,37 @@
# 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.
-local rule try-one-generator ( project name ? : generator :
+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 =
+ local viable-source-types =
[ viable-source-types-for-generator $(generator) ] ;
-
- if $(source-types) && $(viable-source-types) != * &&
- ! [ set.intersection $(source-types) : $(viable-source-types) ]
+
+ 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 matched-types ;
local usage-requirements = [ property-set.empty ] ;
for local t in $(target-types)
{
@@ -922,7 +922,7 @@
}
# TODO: have to introduce parameter controlling if
# several types can be matches and add appropriate
- # checks
+ # checks
# TODO: need to review the documentation for
# 'construct' to see if it should return $(source) even
@@ -938,7 +938,7 @@
}
}
-# Ensures all 'targets' have types. If this is not so, exists with
+# Ensures all 'targets' have types. If this is not so, exists with
# error.
local rule ensure-type ( targets * )
{
@@ -947,10 +947,10 @@
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 it's bases (in the order returned bt
@@ -969,22 +969,22 @@
import type ;
local t = [ type.all-bases $(target-type) ] ;
-
- generators.dout [ indent ] find-viable-generators target-type= $(target-type)
+
+ generators.dout [ indent ] find-viable-generators target-type= $(target-type)
property-set= [ $(property-set).as-path ]
;
-
+
# Get the lit 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]) ;
+ 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're here, when no generators for target-type are found,
@@ -999,22 +999,22 @@
# 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.
- generators2 += [
+ generators2 += [
$(g).clone-and-change-target-type $(t[1]) : $(target-type) ] ;
generators.register $(generators2[-1]) ;
- }
+ }
generators = $(generators2) ;
- }
+ }
t = ;
- }
- t = $(t[2-]) ;
+ }
+ 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)
{
@@ -1022,7 +1022,7 @@
viable-generators += $(g) ;
}
}
-
+
return $(viable-generators) ;
}
@@ -1036,29 +1036,29 @@
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)
+ # Avoid trying the same generator twice on different levels.
+ if ! $(g) in $(.active-generators)
{
viable-generators += $(g) ;
- }
+ }
}
-
+
# Generators which override 'all'.
local all-overrides ;
# Generators which are overriden
- local overriden-ids ;
+ local overriden-ids ;
for local g in $(viable-generators)
{
local id = [ $(g).id ] ;
@@ -1067,8 +1067,8 @@
if all in $(this-overrides)
{
all-overrides += $(g) ;
- }
- }
+ }
+ }
if $(all-overrides)
{
viable-generators = $(all-overrides) ;
@@ -1079,12 +1079,12 @@
if ! [ $(g).id ] in $(overriden-ids)
{
result += $(g) ;
- }
+ }
}
-
+
return $(result) ;
-}
-
+}
+
.construct-stack = ;
# Attempts to construct target by finding viable generators, running them
@@ -1093,20 +1093,20 @@
project name ? : target-type : property-set : sources * )
{
viable-generators = [ find-viable-generators $(target-type) : $(property-set) ] ;
-
- generators.dout [ indent ] "*** " [ sequence.length $(viable-generators) ]
+
+ 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) ;
@@ -1138,59 +1138,59 @@
else
{
result = $(r) ;
- }
+ }
}
}
-
+
return $(result) ;
-}
-
-
+}
+
+
# 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'.
+# 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.
+# targets.
rule construct ( project name ? : target-type : property-set * : sources * )
{
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 ] ;
+ generators.dout [ indent ] " properties:" [ $(property-set).raw ] ;
}
-
-
- local result = [ construct-really $(project) $(name)
+
+
+ local result = [ construct-really $(project) $(name)
: $(target-type) : $(property-set) : $(sources) ] ;
-
+
decrease-indent ;
-
+
.construct-stack = $(.construct-stack[2-]) ;
-
- return $(result) ;
+
+ return $(result) ;
}
-# Given 'result', obtained from some generator or
+# 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,
@@ -1199,13 +1199,13 @@
{
if $(result)
{
- if [ class.is-a $(result[1]) : property-set ]
+ 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) ;
- }
- }
+ }
+ }
}
Modified: trunk/tools/build/v2/build/modifiers.jam
==============================================================================
--- trunk/tools/build/v2/build/modifiers.jam (original)
+++ trunk/tools/build/v2/build/modifiers.jam 2008-01-05 13:13:10 EST (Sat, 05 Jan 2008)
@@ -153,10 +153,10 @@
}
}
-# A modifier that changes the name of a target, after it's generated, given
-# a regular expression to slpit 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).
+# 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
{
Modified: trunk/tools/build/v2/build/targets.jam
==============================================================================
--- trunk/tools/build/v2/build/targets.jam (original)
+++ trunk/tools/build/v2/build/targets.jam 2008-01-05 13:13:10 EST (Sat, 05 Jan 2008)
@@ -8,10 +8,10 @@
# Supports 'abstract' targets, which are targets explicitly defined in 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).
+# 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
@@ -26,131 +26,128 @@
#
# Rules supplied by the build system will use only targets derived
# from 'basic-target' class, which will provide some default behaviour.
-# There will be two classes derived from it, 'make-target', created by the
-# 'make' rule, and 'typed-target', created by rules such as 'exe' and 'dll'.
+# 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 |
+# |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 sequence ;
-import regex ;
-import property ;
import errors ;
-import common ;
-import property-set ;
-import project ;
import feature ;
-import virtual-target ;
+import indirect ;
import path ;
+import property ;
+import property-set ;
+import sequence ;
import set ;
-import assert ;
-import indirect ;
import toolset ;
# Base class for all abstract targets.
-class abstract-target
+class abstract-target
{
- import project assert "class" errors ;
-
+ 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.
-
+ # 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) ;
}
-
- # 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 property-set with the usage requirements to be
- # applied to dependents
- # - a list of produced virtual targets, which may be
- # empty.
- # If 'property-set' are empty, performs default build of this
- # target, in a way specific to derived class.
+
+ # 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 property-set with the usage requirements to be applied to dependents
+ # - a list of produced virtual targets, which may be empty.
+ # If 'property-set' are empty, performs default build of this target, in a
+ # way specific to 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 ]
+if --debug-building in [ modules.peek : ARGV ]
{
modules.poke : .debug-building : true ;
}
@@ -161,21 +158,23 @@
return $(.indent:J="") ;
}
+
rule increase-indent ( )
{
.indent += " " ;
}
+
rule decrease-indent ( )
{
.indent = $(.indent[2-]) ;
}
+
# Project target class (derived from 'abstract-target')
#
# This class these responsibilities:
-# - maintaining a list of main target in this project and
-# building it
+# - 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.
@@ -183,31 +182,32 @@
# targets.
# - The first time 'main-target' or 'has-main-target' rule is called,
# all alternatives are enumerated an main targets are created.
-class project-target : abstract-target
+class project-target : abstract-target
{
- import project targets ;
+ import project ;
+ import targets ;
import path ;
import print ;
import property-set ;
- import set : difference : set.difference ;
+ 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
@@ -216,8 +216,8 @@
{
return $(self.project-module) ;
}
-
- rule get ( attribute )
+
+ rule get ( attribute )
{
return [ project.attribute $(self.project-module) $(attribute) ] ;
}
@@ -225,57 +225,57 @@
rule build-dir ( )
{
if ! $(self.build-dir)
- {
+ {
self.build-dir = [ get build-dir ] ;
if ! $(self.build-dir)
{
- self.build-dir = [ path.join
+ 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 ]
+ 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 ]
+
+ 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) ] ;
+ 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) ;
}
}
@@ -286,10 +286,10 @@
{
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 )
@@ -298,19 +298,18 @@
# rule is called before main target instaces are created.
self.explicit-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."
+ 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 the 'name'.
rule main-target ( name )
{
@@ -318,7 +317,7 @@
{
build-main-targets ;
}
-
+
return $(self.main-target.$(name)) ;
}
@@ -329,22 +328,22 @@
{
build-main-targets ;
}
-
- if $(self.main-target.$(name))
+
+ if $(self.main-target.$(name))
{
return true ;
- }
+ }
}
# Find and return the target with the specified id, treated
# relative to self.
rule find-really ( id )
{
- local result ;
+ local result ;
local project = $(self.project) ;
local current-location = [ get location ] ;
-
- local split = [ MATCH (.*)//(.*) : $(id) ] ;
+
+ local split = [ MATCH (.*)//(.*) : $(id) ] ;
local project-part = $(split[1]) ;
local target-part = $(split[2]) ;
@@ -356,16 +355,16 @@
local pm = [ project.find $(project-part) : $(current-location) ] ;
if $(pm)
{
- project-target = [ project.target $(pm) ] ;
+ project-target = [ project.target $(pm) ] ;
result = [ $(project-target).find $(target-part) : no-error ] ;
- }
+ }
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:
#
@@ -373,35 +372,35 @@
# 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 = [ main-target $(id) ] ;
-
+ # 'test' on the disk. We need target to override the file.
+ result = [ main-target $(id) ] ;
+
if ! $(result)
{
result = [ new file-reference [ path.make $(id) ] : $(project) ] ;
-
+
if ! [ $(result).exists ]
{
# File actually does not exist.
# Reset 'target' so that an error is issued.
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) ;
}
-
+
rule find ( id : no-error ? )
{
local v = $(.id.$(id)) ;
@@ -414,11 +413,11 @@
}
.id.$(id) = $(v) ;
}
-
+
if $(v) != none
{
return $(v) ;
- }
+ }
else
{
if ! $(no-error)
@@ -430,12 +429,10 @@
ECHO "error: '$(current-location)'" ;
ECHO $(extra-error-message) ;
EXIT ;
- }
- }
+ }
+ }
}
-
-
rule build-main-targets ( )
{
self.built-main-targets = true ;
@@ -450,11 +447,11 @@
self.main-targets += $(t) ;
target = $(self.main-target.$(name)) ;
}
-
- $(target).add-alternative $(a) ;
- }
- }
-
+
+ $(target).add-alternative $(a) ;
+ }
+ }
+
# Accessor, add a constant.
rule add-constant (
name # Variable name of the constant.
@@ -467,14 +464,14 @@
case path :
local r ;
for local v in $(value)
- {
+ {
v = [ path.root [ path.make $(v) ] $(self.location) ] ;
# 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)
@@ -485,28 +482,28 @@
# Inject the constant in the scope of project-root module
modules.poke $(self.project-module) : $(name) : $(value) ;
}
-
+
rule inherit ( parent )
{
- for local c in [ modules.peek $(parent) : self.constants ]
+ 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)
+ add-constant $(c)
: [ modules.peek $(parent) : self.constant.$(c) ] ;
- }
+ }
- # Import rules from parent
+ # Import rules from parent
local this-module = [ project-module ] ;
local parent-module = [ $(parent).project-module ] ;
# Don't import rules which comes from 'project-rules', they
# must be imported localized.
- local user-rules = [ set.difference
+ 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) ;
- }
+ }
}
@@ -520,14 +517,15 @@
{
names += [ $(t).full-name ] ;
}
-
- errors.error "Recursion in main target references"
+
+ errors.error "Recursion in main target references"
: "the following target are being built currently:"
: $(names) ;
}
- .targets-being-built += $(main-target-instance) ;
+ .targets-being-built += $(main-target-instance) ;
}
+
local rule end-building ( main-target-instance )
{
.targets-being-built = $(.targets-being-built[1--2]) ;
@@ -537,20 +535,20 @@
# A named top-level target in Jamfile
class main-target : abstract-target
{
- import errors : error ;
+ import errors ;
import assert ;
- import sequence ;
+ import sequence ;
import print ;
- import build-request feature property-set ;
+ import build-request ;
+ import feature ;
+ import property-set ;
import targets : start-building end-building ;
- import "class" : is-a ;
-
+
rule __init__ ( name : project )
{
abstract-target.__init__ $(name) : $(project) ;
}
-
-
+
# Add a new alternative for this target
rule add-alternative ( target )
{
@@ -565,7 +563,7 @@
else
{
self.default-build = $(d) ;
- }
+ }
self.alternatives += $(target) ;
}
@@ -577,39 +575,39 @@
# 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 ] ;
-
+ # 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 new best viable alternative, we compare it
- # with the current one.
-
+ # with the current one.
+
local best ;
local best-properties ;
-
+
if $(self.alternatives[2-])
{
local bad ;
- local worklist = $(self.alternatives) ;
+ local worklist = $(self.alternatives) ;
while $(worklist) && ! $(bad)
{
- local v = $(worklist[1]) ;
- local properties = [ $(v).match $(property-set) $(debug) ] ;
-
+ 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)
+ else if $(properties) in $(best-properties)
{
# Do nothing, this alternative is worse
}
@@ -618,43 +616,43 @@
best = $(v) ;
best-properties = $(properties) ;
}
- else
+ else
{
bad = true ;
- }
+ }
}
}
- worklist = $(worklist[2-]) ;
+ worklist = $(worklist[2-]) ;
}
if ! $(bad)
{
return $(best) ;
- }
+ }
}
else
{
return $(self.alternatives) ;
- }
+ }
}
-
-
+
+
rule apply-default-build ( property-set )
- {
+ {
# 1. First, see what properties from default-build
- # are already present in property-set.
-
+ # are already present in property-set.
+
local raw = [ $(property-set).raw ] ;
local specified-features = $(raw:G) ;
-
+
local defaults-to-apply ;
- for local d in [ $(self.default-build).raw ]
+ for local d in [ $(self.default-build).raw ]
{
if ! $(d:G) in $(specified-features)
{
- defaults-to-apply += $(d) ;
- }
+ defaults-to-apply += $(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
@@ -662,9 +660,9 @@
local result ;
if $(defaults-to-apply)
{
- properties = [
- build-request.expand-no-defaults
-
+ properties = [
+ build-request.expand-no-defaults
+
# We have to compress subproperties here to prevent
# property lists like:
#
@@ -679,23 +677,23 @@
# be an indication that
# build-request.expand-no-defaults is the wrong rule
# to use here.
- [ feature.compress-subproperties $(raw) ]
+ [ feature.compress-subproperties $(raw) ]
$(defaults-to-apply)
] ;
-
+
if $(properties)
- {
+ {
for local p in $(properties)
{
- result += [ property-set.create
+ result += [ property-set.create
[ feature.expand [ feature.split $(p) ] ] ] ;
}
}
else
{
result = [ property-set.empty ] ;
- }
-
+ }
+
}
else
{
@@ -703,7 +701,7 @@
}
return $(result) ;
}
-
+
# 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.
@@ -715,7 +713,7 @@
# 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 ;
@@ -729,16 +727,16 @@
}
}
end-building $(__name__) ;
- return $(usage-requirements) [ sequence.unique $(result) ] ;
+ 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's possible
# that no targets are generated.
local rule generate-really ( property-set )
- {
+ {
local best-alternatives = [ select-alternatives $(property-set) ] ;
if ! $(best-alternatives)
{
@@ -749,12 +747,12 @@
else
{
local result = [ $(best-alternatives).generate $(property-set) ] ;
-
+
# Now return virtual targets for the only alternative
return $(result) ;
- }
+ }
}
-
+
rule rename ( new-name )
{
abstract-target.rename $(new-name) ;
@@ -762,33 +760,32 @@
{
$(a).rename $(new-name) ;
}
-
+
}
-
}
# Abstract target which refers to a source file.
-# This is artificial creature; it's usefull so that sources to
+# This is artificial creature; it's usefull so that sources to
# a target can be represented as list of abstract target instances.
-class file-reference : abstract-target
+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 )
{
location ;
- return [ property-set.empty ]
+ return [ property-set.empty ]
[ virtual-target.from-file $(self.name)
: $(self.file-location)
- : $(self.project) ] ;
- }
+ : $(self.project) ] ;
+ }
# Returns true if the referred file really exists;
rule exists ( )
@@ -796,7 +793,7 @@
location ;
return $(self.file-path) ;
}
-
+
# Returns the location of target. Needed by 'testing.jam'
rule location ( )
{
@@ -838,7 +835,7 @@
# Find the target
local target = [ $(project).find $(id) ] ;
-
+
return $(target) [ property-set.create $(sproperties) ] ;
}
@@ -849,17 +846,17 @@
# Returns a list consisting of
# - usage requirements
# - generated virtual targets, if any
-rule generate-from-reference
+rule generate-from-reference
( target-reference # Target reference
: project # Project where the reference is made
- : property-set # Properties of the main target that
+ : 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 ] ;
@@ -874,29 +871,28 @@
return [ $(target).generate $(rproperties) ] ;
}
-# Given build request and requirements, return properties
-# common to dependency build request and target build
-# properties
+# Given build request and requirements, return properties common to dependency
+# build request and target build properties.
rule common-properties ( build-request requirements )
{
# For optimization, we add free requirements directly,
# without using complex algorithsm.
# This gives the complex algorithm better chance of caching results.
- local free = [ $(requirements).free ] ;
- local non-free = [ property-set.create
+ 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) ] ;
- }
+ {
+ $(key) = [ common-properties2 $(build-request) $(non-free) ] ;
+ }
result = [ $($(key)).add-raw $(free) ] ;
}
# 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
+# 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.
#
@@ -905,31 +901,31 @@
#
# <toolset>gcc:<variant>release <variant>release:<define>RELEASE
#
-# If 'what' is 'refined' returns context refined with new requirements.
+# If 'what' is 'refined' returns context refined with new requirements.
# If 'what' is 'added' returns just the requirements that must be applied.
rule evaluate-requirements ( 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:
+ # Apply non-conditional requirements.
+ # It's 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'm not sure if this should be an error, or not, especially given that
#
- # <threading>single
+ # <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'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.
-
+ # 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 occurence of '<indirect-conditional>' feature.
@@ -938,41 +934,41 @@
# stabilize before we've done. It's supposed to #conditionals iterations
# should be enough for properties to propagate along conditions in any
# direction.
- local count = $(conditionals)
- [ $(requirements).get <conditional> ]
+ local count = $(conditionals)
+ [ $(requirements).get <conditional> ]
and-once-more ;
-
+
local added-requirements ;
-
+
local current = $(raw) ;
-
+
# 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
+ # by <indirect-conditional> properties can't add new
# <indirect-conditional> properties. So the list of indirect conditionals
# does not change.
local indirect = [ $(requirements).get <conditional> ] ;
- indirect = [ MATCH @(.*) : $(indirect) ] ;
-
+ indirect = [ MATCH @(.*) : $(indirect) ] ;
+
local ok ;
- while $(count)
+ while $(count)
{
# Evaluate conditionals in context of current properties
- local e = [ property.evaluate-conditionals-in-context $(conditionals)
+ 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've found final properties.
- count = ;
+ count = ;
ok = true ;
- }
+ }
else
{
# Oops, results of evaluation of conditionals has changed.
@@ -981,91 +977,94 @@
# requirements.
added-requirements = $(e) ;
current = [ property.refine $(raw) : [ feature.expand $(e) ] ] ;
- }
+ }
count = $(count[2-]) ;
}
if ! $(ok)
{
errors.error "Can't evaluate conditional properties " $(conditionals) ;
}
-
+
if $(what) = added
{
return [ property-set.create $(unconditional) $(added-requirements) ] ;
}
else if $(what) = refined
- {
- return [ property-set.create $(current) ] ;
+ {
+ 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 result, unless they are overrided by some requirement.
# FIXME: 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 [ evaluate-requirements $(requirements)
+
+ return [ evaluate-requirements $(requirements)
: $(build-request) : refined ] ;
}
-# 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.
+# 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 virtual-target targets ;
+ import virtual-target ;
+ import targets ;
import property-set ;
- import set sequence errors ;
+ import set ;
+ import sequence ;
+ import errors ;
import "class" : new ;
- import property feature ;
+ import property ;
+ import feature ;
import build-system ;
-
+
rule __init__ ( name : project
- : sources * : requirements * :
+ : 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)
+ 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 ] ;
}
}
-
+
# Returns the list of abstract-targets which are used as sources.
# The extra properties specified for sources are not represented.
# The only user of this rule at the moment is the "--dump-tests"
@@ -1075,33 +1074,33 @@
if ! $(self.source-targets) {
for local s in $(self.sources)
{
- self.source-targets +=
+ 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'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
+ # <toolset>msvc-6.0
# in requirements.
- # On the other hand, if we have <variant>release in condition it
+ # 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.
local bcondition = [ $(self.requirements).base ] ;
@@ -1110,134 +1109,134 @@
if $(debug)
{
ECHO " next alternative: required properties:" $(condition:E=(empty)) ;
- }
-
- if $(condition) in [ $(property-set).raw ]
+ }
+
+ if $(condition) in [ $(property-set).raw ]
{
if $(debug)
{
ECHO " matched" ;
- }
- return $(condition) ;
+ }
+ 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 to variable called 'result-var'.
# Usage requirements are added variable called 'usage-requirements-var'.
- rule generate-dependencies ( dependencies * : property-set
+ 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)
+
+ 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 ]
+ 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).raw ] ;
+ ECHO [ targets.indent ] "Build request: " [ $(property-set).raw ] ;
local cf = [ build-system.command-line-free-features ] ;
- ECHO [ targets.indent ] "Command line free features: "
+ ECHO [ targets.indent ] "Command line free features: "
[ $(cf).raw ] ;
- ECHO [ targets.indent ] "Target requirements: " [ $(self.requirements).raw ] ;
+ ECHO [ targets.indent ] "Target requirements: " [ $(self.requirements).raw ] ;
}
-
- if ! $(self.generated.$(property-set))
+
+ if ! $(self.generated.$(property-set))
{
# Apply free features form the command line. If user
- # said
+ # said
# define=FOO
# he most likely want this define to be set for all compiles.
- property-set = [ $(property-set).refine
+ 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 ]
+ 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)
+ : $(rproperties)
: properties usage-requirements ;
-
+
generate-dependencies $(self.sources) : $(rproperties)
: source-targets usage-requirements ;
-
- if [ modules.peek : .debug-building ]
+
+ if [ modules.peek : .debug-building ]
{
ECHO ;
- ECHO [ targets.indent ]
+ ECHO [ targets.indent ]
"Usage requirements for $(self.name) are " $(usage-requirements) ;
}
- rproperties = [ property-set.create $(properties)
+ rproperties = [ property-set.create $(properties)
$(usage-requirements) ] ;
usage-requirements = [ property-set.create $(usage-requirements) ] ;
-
- if [ modules.peek : .debug-building ]
+
+ if [ modules.peek : .debug-building ]
{
- ECHO [ targets.indent ]
+ ECHO [ targets.indent ]
"Build properties: " [ $(rproperties).raw ] ;
}
-
- local extra = [ $(rproperties).get <source> ] ;
+
+ local extra = [ $(rproperties).get <source> ] ;
source-targets += $(extra:G=) ;
# We might get duplicate sources, for example if
# we link to two library which have the same <library> in
# usage requirements.
source-targets = [ sequence.unique $(source-targets) ] ;
-
- local result =
- [ construct $(self.name) :
+
+ local result =
+ [ construct $(self.name) :
$(source-targets) : $(rproperties) ] ;
-
+
if $(result)
{
local gur = $(result[1]) ;
result = $(result[2-]) ;
- local s = [ create-subvariant
+ local s = [ create-subvariant
$(result) :
- [ virtual-target.recent-targets ]
+ [ virtual-target.recent-targets ]
: $(property-set) : $(source-targets)
: $(rproperties) : $(usage-requirements) ] ;
virtual-target.clear-recent-targets ;
@@ -1245,72 +1244,72 @@
local ur = [ compute-usage-requirements $(s) ] ;
ur = [ $(ur).add $(gur) ] ;
$(s).set-usage-requirements $(ur) ;
- if [ modules.peek : .debug-building ]
+ if [ modules.peek : .debug-building ]
{
ECHO [ targets.indent ]
"Usage requirements from $(self.name) are "
[ $(ur).raw ] ;
}
-
+
self.generated.$(property-set) = $(ur) $(result) ;
}
- }
+ }
else
{
- if $(rproperties[1]) = "@error"
+ if $(rproperties[1]) = "@error"
{
- ECHO [ targets.indent ]
+ ECHO [ targets.indent ]
"Skipping build of: " [ full-name ] " cannot compute common properties" ;
}
else if [ $(rproperties).get <build> ] = no
{
- ECHO [ targets.indent ]
+ ECHO [ targets.indent ]
"Skipping build of: " [ full-name ] " <build>no in common properties" ;
}
else
{
ECHO [ targets.indent ] "Skipping build of: " [ full-name ] " unknown reason" ;
}
-
- # We're here either because there's error computing
- # properties, or there's <build>no in properties.
- # In the latter case we don't want any diagnostic.
- # In the former case, we need diagnostics. FIXME.
+
+ # We're here either because there's been an error computing
+ # properties, or there's <build>no in properties. In the latter
+ # case we don't want any diagnostic. In the former case, we need
+ # diagnostics. FIXME
self.generated.$(property-set) = $(rproperties) ;
- }
- }
+ }
+ }
else
{
- if [ modules.peek : .debug-building ]
+ if [ modules.peek : .debug-building ]
{
ECHO [ targets.indent ] "Already built" ;
- }
+ }
}
targets.decrease-indent ;
return $(self.generated.$(property-set)) ;
}
- # Given the set of generated targets, and refined build
+ # Given the set of generated targets, and refined build
# properties, determines and sets appripriate 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 ] ;
-
+ 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 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've got from sources, except
# for the <pch-header> and <pch-file> features.
#
@@ -1319,7 +1318,7 @@
#
# pch pch1 : ...
# lib lib1 : ..... pch1 ;
- # pch pch2 :
+ # pch pch2 :
# lib lib2 : pch2 lib1 ;
#
# Here, lib2 should not get <pch-header> property from pch1.
@@ -1330,42 +1329,42 @@
# features are special.
local raw = [ $(subvariant).sources-usage-requirements ] ;
raw = [ $(raw).raw ] ;
- raw = [ property.change $(raw) : <pch-header> ] ;
- raw = [ property.change $(raw) : <pch-file> ] ;
- result = [ $(result).add [ property-set.create $(raw) ] ] ;
-
+ raw = [ property.change $(raw) : <pch-header> ] ;
+ raw = [ property.change $(raw) : <pch-file> ] ;
+ result = [ $(result).add [ property-set.create $(raw) ] ] ;
+
return $(result) ;
}
-
+
# Creates a new subvariant-dg instances for 'targets'
# - 'root-targets' the virtual targets will be returned to dependents
- # - 'all-targets' all virtual
+ # - 'all-targets' all virtual
# targets created while building this main target
# - 'build-request' is property-set instance with requested build properties
- local rule create-subvariant ( root-targets *
+ local rule create-subvariant ( root-targets *
: all-targets * : build-request : sources * :
- rproperties
+ rproperties
: usage-requirements )
{
- for local e in $(root-targets)
+ for local e in $(root-targets)
{
$(e).root true ;
- }
-
+ }
+
# Process all vtargets 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)
+ for local v in $(all-targets)
{
if ! [ $(v).creating-subvariant ]
- {
- $(v).creating-subvariant $(s) ;
- }
- }
+ {
+ $(v).creating-subvariant $(s) ;
+ }
+ }
return $(s) ;
}
-
+
# Constructs the virtual targets for this abstract targets and
# the dependecy graph. Returns the list of virtual targets.
# Should be overrided in derived classes.
@@ -1375,59 +1374,59 @@
}
}
+
class typed-target : basic-target
{
- import generators ;
-
- rule __init__ ( name : project : type
- : sources * : requirements * : default-build * : usage-requirements * )
+ import generators ;
+
+ rule __init__ ( name : project : type
+ : sources * : requirements * : default-build * : usage-requirements * )
{
- basic-target.__init__ $(name) : $(project)
+ 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 ] # [ feature.expand
- <main-target-type>$(self.type) ]
- # ]
+ local r = [ generators.construct $(self.project) $(name:S=) : $(self.type)
+ : [ property-set.create [ $(property-set).raw ]
+ <main-target-type>$(self.type) ]
: $(source-targets) ] ;
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
+ 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 is non-empty value is passed for 'no-renaming' parameter.
-#
+
+# 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 for 'no-renaming' parameter.
+#
rule main-target-sources ( sources * : main-target-name : no-renaming ? )
{
local result ;
@@ -1435,74 +1434,76 @@
{
if [ class.is-instance $(t) ]
{
- local name = [ $(t).name ] ;
+ 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) ;
+ $(p).mark-target-as-explicit $(name) ;
result += $(name) ;
}
else
{
result += $(t) ;
- }
- }
+ }
+ }
return $(result) ;
}
-# Returns the requirement to use when declaring a main target,
-# which are obtained by
+# 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
-rule main-target-requirements (
- specification * # Properties explicitly specified for a main target
- : project # Project where the main target is to be declared
- )
+rule main-target-requirements (
+ specification * # Properties explicitly specified for a main target
+ : project # Project where the main target is to be declared
+)
{
specification += [ toolset.requirements ] ;
-
- local requirements = [ property-set.refine-from-user-input
+
+ local requirements = [ property-set.refine-from-user-input
[ $(project).get requirements ] : $(specification) :
[ $(project).project-module ] : [ $(project).get location ] ] ;
-
- if $(requirements[1]) = "@error"
+
+ if $(requirements[1]) = "@error"
{
errors.error "Conflicting requirements for target:" $(requirements) ;
}
return $(requirements) ;
}
-# Returns the use requirement to use when declaraing a main target,
-# which are obtained by
+
+# Returns the use requirement 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
- )
+ specification * # Use-properties explicitly specified for a main target
+ : project # Project where the main target is to be declared
+)
{
- local loc = [ $(project).get location ] ;
+ local loc = [ $(project).get location ] ;
local 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.
- local usage-requirements = [ property-set.create-from-user-input
- $(specification)
+ 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 specified value if not empty and parent's
-# default build attribute otherwise.
+
+# 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
@@ -1516,33 +1517,33 @@
else
{
result = [ $(project).get default-build ] ;
- }
+ }
return [ property-set.create-with-validation $(result) ] ;
-}
+}
+
# Registers the specified target as a main target alternatives.
# Returns 'target'.
-rule main-target-alternative ( target )
-{
+rule main-target-alternative ( target )
+{
local ptarget = [ $(target).project ] ;
-
$(ptarget).add-alternative $(target) ;
return $(target) ;
}
-# 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 *
+
+# 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-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) ]
] ] ;
Modified: trunk/tools/build/v2/build/type.jam
==============================================================================
--- trunk/tools/build/v2/build/type.jam (original)
+++ trunk/tools/build/v2/build/type.jam 2008-01-05 13:13:10 EST (Sat, 05 Jan 2008)
@@ -1,7 +1,7 @@
-# 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)
+# 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.
@@ -16,32 +16,29 @@
# This creates a circular dependency
# project-test1 -> project -> project-root -> builtin -> type -> targets -> project
-# import targets ;
+# import targets ;
-# The feature is optional so that it never implicitly added.
-# It's used only for internal purposes, and in all cases we
-# want to explicitly use it.
+# The feature is optional so it would never get added implicitly. It's used only
+# for internal purposes and in all cases we want to use it explicitly.
feature.feature target-type : : composite optional ;
-# feature.feature base-target-type : : composite optional ;
feature.feature main-target-type : : optional incidental ;
feature.feature base-target-type : : composite optional free ;
-# feature.feature main-target-type : : composite optional incidental ;
-# Registers a target type, possible derived from a 'base-type'.
-# If 'suffixes' are provided, they given 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'.
+# 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 will be interpreted as composite features
- # which need to be decomposed.
+ # 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." ;
@@ -50,73 +47,72 @@
{
.types += $(type) ;
.bases.$(type) = $(base-type) ;
- .derived.$(base-type) += $(type) ;
+ .derived.$(base-type) += $(type) ;
- if $(suffixes)-not-empty
- {
- # Generated targets of 'type' will use the first of 'suffixes'
- # (this may be overriden)
- $(.suffixes).insert <target-type>$(type) : $(suffixes[1]) ;
+ if $(suffixes)-is-not-empty
+ {
# Specify mapping from suffixes to type
register-suffixes $(suffixes) : $(type) ;
+ # 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 target-type : $(type) ;
feature.extend main-target-type : $(type) ;
-
- feature.compose <target-type>$(type) : $(base-type:G=<base-target-type>) ;
feature.extend base-target-type : $(type) ;
-# feature.compose <target-type>$(type) : <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 main target rule only when 'main' parameter
- # is specified. However, it's hard to decide that a type *never*
- # will need a main target rule and so from time to time we needed
- # to make yet another type 'main'. So, now main target rule is defined
- # for each type.
- main-rule-name = [ type-to-rule-name $(type) ] ;
- .main-target-type.$(main-rule-name) = $(type) ;
-
+ # We used to declare the main target rule only when a 'main' parameter
+ # was specified. However, it's 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) ;
}
}
-# Given type, returns name of main target rule which creates
-# targets of that 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.ame.
import regex ;
local n = [ regex.split $(type:L) "_" ] ;
- n = $(n:J=-) ;
- return $(n) ;
+ return $(n:J=-) ;
}
-# Returns a type, given the name of a main rule.
-rule type-from-rule-name ( main-target-name )
+
+# 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.$(main-target-name)) ;
+ return $(.main-target-type.$(rule-name)) ;
}
-
-# Specifies that targets with suffix from 'suffixes' has the type 'type'.
-# If different type is already specified for any of syffixes,
-# issues an error.
+# 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))
+ {
+ if ! $(.type.$(s))
{
- .type.$(s) = $(type) ;
+ .type.$(s) = $(type) ;
}
- else if $(.type.$(s)) != type
+ else if $(.type.$(s)) != type
{
- errors.error Attempting to specify type for suffix \"$(s)\"
+ errors.error Attempting to specify multiple types for suffix \"$(s)\"
: "Old type $(.type.$(s)), New type $(type)" ;
}
- }
+ }
}
@@ -129,13 +125,14 @@
}
}
+
# Issues an error if 'type' is unknown.
rule validate ( type )
{
if ! $(type) in $(.types)
{
errors.error "Unknown target type $(type)" ;
- }
+ }
}
@@ -145,18 +142,20 @@
if ! $(type) in $(.types)
{
error "Type" $(type) "is not declared" ;
- }
+ }
.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 type and all of its bases in order of their distance from type.
rule all-bases ( type )
{
@@ -169,6 +168,7 @@
return $(result) ;
}
+
rule all-derived ( type )
{
local result = $(type) ;
@@ -176,12 +176,11 @@
{
result += [ all-derived $(d) ] ;
}
- return $(result) ;
+ return $(result) ;
}
-# Returns true if 'type' has 'base' as its direct or
-# indirect base.
+# Returns true if 'type' has 'base' as its direct or indirect base.
rule is-derived ( type base )
{
if $(base) in [ all-bases $(type) ]
@@ -190,8 +189,8 @@
}
}
-# Returns true if 'type' is either derived from 'base',
-# or 'type' is equal to 'base'.
+
+# Returns true if 'type' is either derived from or is equal to 'base'.
rule is-subtype ( type base )
{
if $(type) = $(base)
@@ -201,7 +200,7 @@
else
{
return [ is-derived $(type) $(base) ] ;
- }
+ }
}
@@ -212,99 +211,108 @@
.prefixes = [ new property-map ] ;
-# 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.
+# 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.
#
-# The 'suffix' parameter can be empty string ("") to indicate that
-# no suffix should be used.
rule set-generated-target-suffix ( type : properties * : suffix )
{
- set-generated-target-ps 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.
+
+# 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) ;
+{
+ 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) ] ;
+ return [ generated-target-ps suffix : $(type) : $(property-set) ] ;
}
-# Sets a target prefix that should be used when generating target
-# of 'type' with the specified properties. Can be called with
-# empty properties if no prefix for 'type' was specified yet.
+
+# 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.
+# The 'prefix' parameter can be empty string ("") to indicate that no prefix
+# should be used.
#
-# Example usage is for library names that have to have a "lib"
-# prefix as in unix.
+# 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) ;
-}
+ 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.
+# 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) ;
+{
+ change-generated-target-ps prefix : $(type) : $(properties) : $(prefix) ;
}
+
rule generated-target-prefix ( type : property-set )
{
- return [ generated-target-ps prefix : $(type) : $(property-set) ] ;
+ return [ generated-target-ps prefix : $(type) : $(property-set) ] ;
}
+
# Common rules for prefix/suffix provisioning follow
-rule set-generated-target-ps ( ps : type : properties * : psval )
+local rule set-generated-target-ps ( ps : type : properties * : psval )
{
properties = <target-type>$(type) $(properties) ;
$(.$(ps)es).insert $(properties) : $(psval) ;
-}
+}
+
-rule change-generated-target-ps ( ps : type : properties * : psval )
-{
- properties = <target-type>$(type) $(properties) ;
+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 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.
-rule generated-target-ps-real ( ps : type : properties * )
+
+# 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 empty string,
- # we consider prefix/suffix to be found. If we did not compare with "",
- # there would be no way for user to set empty prefix/suffix.
+ # 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 = $(.bases.$(type)) ;
}
- if $(result) = ""
+ if $(result) = ""
{
result = ;
}
@@ -312,7 +320,7 @@
}
-rule generated-target-ps ( ps : type : property-set )
+local rule generated-target-ps ( ps : type : property-set )
{
local key = .$(ps).$(type).$(property-set) ;
local v = $($(key)) ;
@@ -326,21 +334,21 @@
}
$(key) = $(v) ;
}
-
+
if $(v) != none
{
return $(v) ;
- }
+ }
}
# 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.
-rule type ( filename )
+# tries each suffix. E.g. for name of "file.so.1.2" suffixes "2", "1", and "so"
+# will be tried.
+rule type ( filename )
{
local type ;
- while ! $(type) && $(filename:S)
+ while ! $(type) && $(filename:S)
{
local suffix = $(filename:S) ;
type = $(.type$(suffix)) ;
@@ -350,21 +358,23 @@
}
-
-rule main-target-rule ( name : sources * : requirements * : default-build *
+# Rule used to construct all main targets. Note that this rule gets imported
+# into the global namespace under different names and exactly what type of
+# target it is supposed to construct is read from the name of the rule actually
+# used to invoke it.
+rule main-target-rule ( name : sources * : requirements * : default-build *
: usage-requirements * )
{
- # First find required target type, which is equal to the name used
+ # First find the required target type, which is equal to the rule name used
# to invoke us.
local bt = [ BACKTRACE 1 ] ;
local rulename = $(bt[4]) ;
-
+
local project = [ project.current ] ;
-
+
# This is a circular module dependency, so it must be imported here
import targets ;
- return [ targets.create-typed-target $(.main-target-type.$(rulename)) : $(project)
- : $(name) : $(sources) : $(requirements)
- : $(default-build) : $(usage-requirements) ] ;
+ return [ targets.create-typed-target $(.main-target-type.$(rulename))
+ : $(project) : $(name) : $(sources) : $(requirements)
+ : $(default-build) : $(usage-requirements) ] ;
}
-
Modified: trunk/tools/build/v2/build/virtual-target.jam
==============================================================================
--- trunk/tools/build/v2/build/virtual-target.jam (original)
+++ trunk/tools/build/v2/build/virtual-target.jam 2008-01-05 13:13:10 EST (Sat, 05 Jan 2008)
@@ -1,8 +1,8 @@
-# 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)
+# 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
# build, but are not yet targets in Jam sense. They are needed, for example,
@@ -10,7 +10,14 @@
# if particular target should be created at all.
import "class" : new ;
-import path property-set utility sequence errors set type os ;
+import path ;
+import property-set ;
+import utility ;
+import sequence ;
+import errors ;
+import set ;
+import type ;
+import os ;
# +--------------------------+
# | virtual-target |
@@ -64,19 +71,22 @@
# building, if needed. However, it can be also dropped, which allows
# to search for different transformation and select only one.
#
-class virtual-target
+class virtual-target
{
- import virtual-target utility scanner ;
-
+ import scanner ;
+ import sequence ;
+ import utility ;
+ import virtual-target ;
+
rule __init__ ( name # Name of this target -- specifies the name of
: project # Project to which this target belongs
)
- {
+ {
self.name = $(name) ;
self.project = $(project) ;
self.dependencies = ;
}
-
+
# Name of this target.
rule name ( ) { return $(self.name) ; }
@@ -149,14 +159,14 @@
{
errors.error "method should be defined in derived classes" ;
}
-
+
# If the target is generated one, returns the path where it will be
# generated. Otherwise, returns empty list.
rule path ( )
{
- errors.error "method should be defined in derived classes" ;
+ errors.error "method should be defined in derived classes" ;
}
-
+
# Return that actual target name that should be used
# (for the case where no scanner is involved)
rule actual-name ( )
@@ -167,11 +177,11 @@
# implementation
rule actualize-no-scanner ( )
{
- # In fact, we just need to merge virtual-target with
+ # In fact, we just need to merge virtual-target with
# abstract-virtual-target and the latter is the only class
# derived from the former. But that's for later.
- errors.error "method should be defined in derived classes" ;
- }
+ errors.error "method should be defined in derived classes" ;
+ }
}
@@ -187,11 +197,15 @@
# value identifying the main target.
class abstract-file-target : virtual-target
{
- import project regex sequence path type ;
+ import project ;
+ import regex ;
+ import sequence ;
+ import path ;
+ import type ;
import property-set ;
import indirect ;
-
- rule __init__ (
+
+ rule __init__ (
name # Name for this target
exact ? # If non-empty, the name is exactly the name
# created file should have. Otherwise, the '__init__'
@@ -203,20 +217,20 @@
)
{
virtual-target.__init__ $(name) : $(project) ;
-
+
self.type = $(type) ;
self.action = $(action) ;
if $(action)
- {
+ {
$(action).add-targets $(__name__) ;
- if $(self.type) && ! $(exact)
- {
+ if $(self.type) && ! $(exact)
+ {
_adjust-name $(name) ;
- }
- }
+ }
+ }
}
-
+
rule type ( ) { return $(self.type) ; }
# Sets the path. When generating target name, it will override any path
@@ -243,11 +257,11 @@
}
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 particual, if target is shared by subvariant, only
- # the first is stored.
+ # after that. In particual, if target is shared by subvariant, only
+ # the first is stored.
rule creating-subvariant ( s ? # If specified, specified the value to set,
# which should be instance of 'subvariant'
# class.
@@ -260,9 +274,9 @@
errors.error "Attempt to change 'dg'" ;
}
else
- {
+ {
self.creating-subvariant = $(s) ;
- }
+ }
}
return $(self.creating-subvariant) ;
}
@@ -274,7 +288,7 @@
$(self.action).actualize ;
}
}
-
+
# Return a human-readable representation of this target
#
# If this target has an action, that's:
@@ -288,21 +302,21 @@
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 ;
+ local action-name = [ $(action).action-name ] ;
+
+ local ss ;
for local s in $(sources)
{
ss += [ $(s).str ] ;
}
-
+
return "{" $(action-name)-$(name-dot-type) $(ss) "}" ;
}
else
@@ -331,30 +345,30 @@
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. Compute unique prefix used to distinguish
# this target from other targets with the same name which create different
# file.
rule grist ( )
{
# Depending on target, there may be different approaches to generating
- # unique prefixes. We'll generate prefixes in the form
+ # unique prefixes. We'll 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) ;
+ return p$(path) ;
}
else
{
@@ -363,38 +377,38 @@
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 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.
# The tag properties come in two flavour:
- # - <tag>value,
+ # - <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
+ # <tag> returns nothing, returns the result of calling
# virtual-target.add-suffix
rule _adjust-name ( specified-name )
- {
+ {
local ps ;
- if $(self.action)
+ if $(self.action)
{
ps = [ $(self.action).properties ] ;
}
@@ -402,7 +416,7 @@
{
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
@@ -410,7 +424,7 @@
#~ 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)
@@ -422,23 +436,23 @@
{
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
+ errors.error
"The value of the <tag> feature must be '@rule-nane'" ;
}
}
-
+
# If there's 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 ( )
@@ -448,9 +462,9 @@
# Do anything only on the first invocation
if ! $(self.made.$(name)) {
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
@@ -458,7 +472,7 @@
# and MOCCABLE_CPP (for convertion to H via Qt tools).
virtual-target.register-actual-name $(name) : $(__name__) ;
}
-
+
for local i in $(self.dependencies) {
DEPENDS $(name) : [ $(i).actualize ] ;
}
@@ -468,15 +482,16 @@
}
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.
@@ -488,9 +503,9 @@
{
suffix = .$(suffix) ;
}
-
+
local prefix = [ type.generated-target-prefix $(type) : $(property-set) ] ;
-
+
if [ MATCH ^($(prefix)) : $(specified-name) ]
{
prefix = ;
@@ -513,12 +528,12 @@
# - the value passed to the 'suffix' method, if any, or
# - the suffix which correspond to the target's type.
#
-class file-target : abstract-file-target
+class file-target : abstract-file-target
{
- import common ;
+ import common ;
import errors ;
import "class" : new ;
-
+
rule __init__ (
name exact ?
: type ? # Optional type for this target
@@ -527,25 +542,25 @@
: path ?
)
{
- abstract-file-target.__init__ $(name) $(exact) : $(type) : $(project)
- : $(action) ;
+ 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) ;
+ LOCATE on $(target) = $(path) ;
# Make sure the path exists.
DEPENDS $(target) : $(path) ;
@@ -561,14 +576,14 @@
DEPENDS $(target) : $(d) ;
common.MkDir $(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.
+ # without trying to guess the name of the real target.
# Note the that target has no directory name, and a special
# grist <e>.
#
@@ -585,56 +600,58 @@
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 p = [ $(self.action).properties ] ;
local path = [ $(p).target-path ] ;
-
+
if $(path[2]) = true
- {
+ {
# Indicates that the path is relative to
# build dir.
path = [ path.join [ $(self.project).build-dir ]
$(path[1]) ] ;
}
-
+
# Store the computed path, so that it's not recomputed
# any more
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 target path is not known.
rule path ( )
{
return ;
}
-
+
rule actualize-location ( target )
{
NOTFILE $(target) ;
ALWAYS $(target) ;
- }
-}
+ }
+}
+
# Class which represents an action.
# Both 'targets' and 'sources' should list instances of 'virtual-target'.
@@ -642,34 +659,41 @@
# 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.
-class action
+class action
{
- import type toolset property-set indirect class path assert errors ;
-
+ import type ;
+ import toolset ;
+ import property-set ;
+ import indirect ;
+ import "class" ;
+ import path ;
+ import assert ;
+ import errors ;
+
rule __init__ ( sources * : action-name + : property-set ? )
- {
+ {
self.sources = $(sources) ;
-
+
self.action-name = [ indirect.make-qualified $(action-name) ] ;
-
- if ! $(property-set)
+
+ 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 targets ( )
{
return $(self.targets) ;
@@ -715,16 +739,16 @@
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 ]
+
+ indirect.call $(self.action-name)
+ $(actual-targets) : $(self.actual-sources) : [ $(properties).raw ]
;
-
+
# Since we set up creating action here, we also set up
# action for cleaning up
common.Clean clean-all : $(actual-targets) ;
@@ -747,10 +771,10 @@
}
result += [ $(i).actualize $(scanner) ] ;
}
-
+
return $(result) ;
}
-
+
# Creates actual jam targets for sources. Initialized two member
# variables:.
# 'self.actual-sources' -- sources which are passed to updating action
@@ -762,10 +786,10 @@
rule actualize-sources ( sources * : property-set )
{
local dependencies = [ $(self.properties).get <dependency> ] ;
-
- self.dependency-only-sources += [
+
+ self.dependency-only-sources += [
actualize-source-type $(dependencies) : $(property-set) ] ;
- self.actual-sources += [
+ self.actual-sources += [
actualize-source-type $(sources) : $(property-set) ] ;
# This is used to help bjam find dependencies in generated headers
@@ -783,7 +807,7 @@
for local i in $(implicit)
{
$(i:G=).actualize ;
- }
+ }
}
# Determined real properties when trying building with 'properties'.
@@ -796,17 +820,18 @@
}
}
+
# 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
+# targets with different properties that are known to exist, and have no
# actions which create them.
-class null-action : action
+class null-action : action
{
rule __init__ ( property-set ? )
{
action.__init__ : .no-action : $(property-set) ;
}
-
+
rule actualize ( )
{
if ! $(self.actualized)
@@ -817,16 +842,17 @@
{
$(i).actualize ;
}
- }
+ }
}
}
+
# Class which acts exactly like 'action', except that the sources
# are not scanned for dependencies.
-class non-scanning-action : action
+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 )
@@ -835,21 +861,22 @@
for local i in $(sources)
{
result += [ $(i).actualize ] ;
- }
+ }
return $(result) ;
}
}
-# Creates a virtual target with approariate name and type from 'file'.
-# If a target with that name in that project was already created, returns that already
-# created target.
-# FIXME: 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.
+# 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.
+# FIXME: 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.
rule from-file ( file : file-loc : project )
{
- import type ; # had to do this here to break a circular dependency
+ import type ; # had to do this here to break a circular dependency
# Check if we've created a target corresponding to this file.
local path = [ path.root [ path.root $(file) $(file-loc) ]
@@ -876,52 +903,52 @@
}
}
-# 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 registers.
-# Otherwise, 'target' is registered and returned.
+
+# 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 returned and
+# 'target' is not registered. Otherwise, 'target' is registered and returned.
rule register ( target )
{
local signature = [ sequence.join
- [ $(target).path ] [ $(target).name ] : - ] ;
+ [ $(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
+ else
{
- if $(a1) && $(a2) && [ $(a1).action-name ] = [ $(a2).action-name ] &&
+ 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 ] [ $(ps1).dependency ] ;
local p2 = [ $(ps2).base ] [ $(ps2).free ] [ $(ps2).dependency ] ;
- if $(p1) = $(p2)
- {
+ if $(p1) = $(p2)
+ {
result = $(t) ;
- }
+ }
}
- }
+ }
}
}
-
+
if ! $(result)
{
- .cache.$(signature) += $(target) ;
+ .cache.$(signature) += $(target) ;
result = $(target) ;
}
-
+
.recent-targets += $(result) ;
.all-targets += $(result) ;
@@ -929,28 +956,30 @@
}
-# 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
+# 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... !!!MISSING TEXT HERE!!!
rule recent-targets ( )
{
return $(.recent-targets) ;
}
+
rule clear-recent-targets ( )
{
.recent-targets = ;
}
-# Returns all virtual targets ever created
+
+# 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.
+
+# Returns all targets from 'targets' with types equal to 'type' or derived from
+# it.
rule select-by-type ( type : targets * )
{
local result ;
@@ -959,12 +988,11 @@
if [ type.is-subtype [ $(t).type ] $(type) ]
{
result += $(t) ;
- }
+ }
}
-
- return $(result) ;
-}
+ return $(result) ;
+}
rule register-actual-name ( actual-name : virtual-target )
@@ -975,8 +1003,7 @@
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 ;
@@ -991,26 +1018,26 @@
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 ]
+ }
+ 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)
+ : "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 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.
+# 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.
rule traverse ( target : include-roots ? : include-sources ? )
{
local result ;
@@ -1029,20 +1056,21 @@
else if $(include-roots)
{
result += $(t) ;
- }
+ }
}
}
else if $(include-sources)
{
result = $(target) ;
- }
+ }
return $(result) ;
}
-# 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.
+
+# 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)
@@ -1055,43 +1083,44 @@
}
local action-class = [ modules.peek $(action) : __class__ ] ;
- local cloned-action = [ class.new $(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 ] ;
# Don't modify the name of the produced targets.Strip the directory f
- local cloned-target = [ class.new file-target $(n) exact : [ $(target).type ]
+ 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) ;
+ }
+
+ return $(cloned-action) ;
}
+
class subvariant
{
- import sequence ;
+ 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.main-target = $(main-target) ;
self.properties = $(property-set) ;
self.sources = $(sources) ;
self.build-properties = $(build-properties) ;
@@ -1105,74 +1134,72 @@
{
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 ( )
+
+ 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 with dependency property are returned a properties,
- # not targets.
+
+ # 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 ( )
{
# 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)
- {
+ {
r += [ $(t:G=).creating-subvariant ] ;
}
r = [ sequence.unique $(r) ] ;
- for local s in $(r)
+ for local s in $(r)
{
if $(s) != $(__name__)
{
all-targets += [ $(s).all-referenced-targets ] ;
- }
+ }
}
- return $(all-targets) ;
+ return $(all-targets) ;
}
-
+
# 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.
@@ -1184,13 +1211,13 @@
local key = ii$(feature)-$(target-type:E="") ;
if ! $($(key))-is-nonempty
{
- local target-paths = [ all-target-directories $(target-type) ] ;
+ 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)) = ""
@@ -1200,37 +1227,36 @@
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)
{
- if $(target-type) && ! [ type.is-derived [ $(t).type ] $(target-type) ]
+ if $(target-type) && ! [ type.is-derived [ $(t).type ] $(target-type) ]
{
# Skip target which is of wrong type.
}
else
- {
+ {
result = [ sequence.merge $(result) : [ $(t).path ] ] ;
- }
+ }
}
for local d in $(self.other-dg)
{
result += [ $(d).all-target-directories $(target-type) ] ;
}
self.target-directories = $(result) ;
- }
+ }
}
-
Modified: trunk/tools/build/v2/tools/package.jam
==============================================================================
--- trunk/tools/build/v2/tools/package.jam (original)
+++ trunk/tools/build/v2/tools/package.jam 2008-01-05 13:13:10 EST (Sat, 05 Jan 2008)
@@ -34,7 +34,6 @@
import targets ;
import "class" : new ;
import option ;
-import errors ;
import stage ;
import property ;
@@ -77,7 +76,6 @@
# source header files
local include-locate = [ option.get includedir : $(prefix)/include ] ;
-
stage.install $(name)-bin : $(binaries) : $(requirements) <location>$(bin-locate) ;
stage.install $(name)-lib :
$(binaries) $(libraries)
Modified: trunk/tools/build/v2/tools/stage.jam
==============================================================================
--- trunk/tools/build/v2/tools/stage.jam (original)
+++ trunk/tools/build/v2/tools/stage.jam 2008-01-05 13:13:10 EST (Sat, 05 Jan 2008)
@@ -1,23 +1,19 @@
-# 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)
+# 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)
-# This module defines the 'install' rule, used to copy a set of targets to
-# a single location
+# This module defines the 'install' rule, used to copy a set of targets to a
+# single location
import targets ;
import "class" : new ;
-import property ;
-import errors : error ;
-import type : type ;
+import errors ;
import type ;
-import regex ;
import generators ;
import feature ;
import project ;
-import property-set ;
import virtual-target ;
import path ;
@@ -31,12 +27,20 @@
class install-target-class : basic-target
{
- import feature project type errors generators path stage ;
+ import feature ;
+ import project ;
+ import type ;
+ import errors ;
+ import generators ;
+ import path ;
+ import stage ;
import "class" : new ;
-
+ import property ;
+ import property-set ;
+
rule __init__ ( name-and-dir : project : sources * : requirements * : default-build * )
{
- basic-target.__init__ $(name-and-dir) : $(project) : $(sources) : $(requirements)
+ basic-target.__init__ $(name-and-dir) : $(project) : $(sources) : $(requirements)
: $(default-build) ;
}
@@ -50,195 +54,192 @@
property-set = [ $(property-set).add-raw $(loc:G=<location>) ] ;
}
-
+
return $(property-set) ;
}
-
+
# Takes a target that is installed and property set which is
# used when installing.
rule adjust-properties ( target : build-property-set )
{
local ps-raw ;
- local a = [ $(target).action ] ;
+ local a = [ $(target).action ] ;
if $(a)
{
local ps = [ $(a).properties ] ;
ps-raw = [ $(ps).raw ] ;
-
+
# Unless <hardcode-dll-paths>true is in properties, which can
# happen only if the user has explicitly requested it, nuke all
- # <dll-path> properties
+ # <dll-path> properties
if [ $(property-set).get <hardcode-dll-paths> ] != true
{
ps-raw = [ property.change $(ps-raw) : <dll-path> ] ;
}
-
+
# If any <dll-path> properties were specified for installing,
# add them.
local l = [ $(build-property-set).get <dll-path> ] ;
ps-raw += $(l:G=<dll-path>) ;
-
+
# Also copy <linkflags> feature from current build
# set, to be used for relinking.
local l = [ $(build-property-set).get <linkflags> ] ;
- ps-raw += $(l:G=<linkflags>) ;
+ ps-raw += $(l:G=<linkflags>) ;
}
-
+
# Remove the <tag> feature on original targets.
ps-raw = [ property.change $(ps-raw) : <tag> ] ;
# And <location>. If stage target has another stage target
# in sources, then we'll get virtual targets with <location>
# property set.
ps-raw = [ property.change $(ps-raw) : <location> ] ;
-
-
+
+
local d = [ $(build-property-set).get <dependency> ] ;
ps-raw += $(d:G=<dependency>) ;
-
+
local d = [ $(build-property-set).get <location> ] ;
ps-raw += $(d:G=<location>) ;
-
+
local ns = [ $(build-property-set).get <install-no-version-symlinks> ] ;
ps-raw += $(ns:G=<install-no-version-symlinks>) ;
-
+
local d = [ $(build-property-set).get <install-source-root> ] ;
# Make the path absolute: we'll use it to compute relative
# paths and making the path absolute will help.
if $(d)
- {
+ {
d = [ path.root $(d) [ path.pwd ] ] ;
ps-raw += $(d:G=<install-source-root>) ;
- }
-
+ }
+
if $(ps-raw)
{
return [ property-set.create $(ps-raw) ] ;
- }
+ }
else
{
return [ property-set.empty ] ;
- }
+ }
}
-
-
+
rule construct ( name : source-targets * : property-set )
- {
- source-targets = [
+ {
+ source-targets = [
targets-to-stage $(source-targets) : $(property-set) ] ;
-
- property-set = [ update-location $(property-set) ] ;
-
- local ename = [ $(property-set).get <name> ] ;
-
+
+ property-set = [ update-location $(property-set) ] ;
+
+ local ename = [ $(property-set).get <name> ] ;
+
if $(ename) && $(source-targets[2])
{
- errors.error
+ errors.error
"When <name> property is used in 'install', only one source is allowed" ;
}
-
-
+
local result ;
for local i in $(source-targets)
- {
+ {
local staged-targets ;
-
- local new-properties =
+
+ local new-properties =
[ adjust-properties $(i) : $(property-set) ] ;
-
+
# See if something special should be done when staging this
- # type. It is indicated by presense of special "staged" type
- local t = [ $(i).type ] ;
+ # type. It is indicated by presense of special "staged" type
+ local t = [ $(i).type ] ;
if $(t) && [ type.registered INSTALLED_$(t) ]
{
if $(ename)
{
- error.error "In 'install': <name> property specified with target that requires relinking" ;
+ errors.error "In 'install': <name> property specified with target that requires relinking" ;
}
else
{
- local targets = [ generators.construct $(self.project) $(name) :
+ local targets = [ generators.construct $(self.project) $(name) :
INSTALLED_$(t) : $(new-properties) : $(i) ] ;
- staged-targets += $(targets[2-]) ;
- }
+ staged-targets += $(targets[2-]) ;
+ }
}
- else
- {
+ else
+ {
staged-targets = [ stage.copy-file $(self.project) $(ename)
: $(i) : $(new-properties) ] ;
}
-
+
if ! $(staged-targets)
- {
+ {
errors.error "Unable to generate staged version of " [ $(source).str ] ;
- }
-
- for t in $(staged-targets)
+ }
+
+ for t in $(staged-targets)
{
- result += [ virtual-target.register $(t) ] ;
- }
+ result += [ virtual-target.register $(t) ] ;
+ }
}
-
+
return [ property-set.empty ] $(result) ;
- }
-
+ }
# Given the list of source targets explicitly passed to 'stage',
# returns the list of targets which must be staged.
rule targets-to-stage ( source-targets * : property-set )
- {
+ {
local result ;
-
+
# Traverse the dependencies, if needed.
if [ $(property-set).get <install-dependencies> ] = "on"
{
source-targets = [ collect-targets $(source-targets) ] ;
}
-
+
# Filter the target types, if needed
- local included-types = [ $(property-set).get <install-type> ] ;
+ local included-types = [ $(property-set).get <install-type> ] ;
for local r in $(source-targets)
{
- local ty = [ $(r).type ] ;
+ local ty = [ $(r).type ] ;
if $(ty)
{
# Don't stage searched libs.
if $(ty) != SEARCHED_LIB
{
if $(included-types)
- {
+ {
if [ include-type $(ty) : $(included-types) ]
{
result += $(r) ;
- }
- }
+ }
+ }
else
{
- result += $(r) ;
- }
- }
+ result += $(r) ;
+ }
+ }
}
else if ! $(included-types)
{
# Don't install typeless target if there's
# explicit list of allowed types.
result += $(r) ;
- }
+ }
}
-
+
return $(result) ;
}
-
+
# CONSIDER: figure out why we can't use virtual-target.traverse here.
rule collect-targets ( targets * )
{
# Find subvariants
- local s ;
+ local s ;
for local t in $(targets)
{
s += [ $(t).creating-subvariant ] ;
}
s = [ sequence.unique $(s) ] ;
-
+
local result = $(targets) ;
for local i in $(s)
{
@@ -250,11 +251,11 @@
if $(r:G) != <use>
{
result2 += $(r:G=) ;
- }
- }
- result = [ sequence.unique $(result2) ] ;
+ }
+ }
+ result = [ sequence.unique $(result2) ] ;
}
-
+
# Returns true iff 'type' is subtype of some element of 'types-to-include'.
local rule include-type ( type : types-to-include * )
{
@@ -264,27 +265,27 @@
if [ type.is-subtype $(type) $(types-to-include[1]) ]
{
found = true ;
- }
+ }
types-to-include = $(types-to-include[2-]) ;
}
-
+
return $(found) ;
- }
+ }
}
-# Creates a copy of target 'source'. The 'properties' object should
-# have a <location> property which specifies where the target must
-# be placed.
+
+# Creates a copy of target 'source'. The 'properties' object should have a
+# <location> property which specifies where the target must be placed.
rule copy-file ( project name ? : source : properties )
-{
+{
local targets ;
name ?= [ $(source).name ] ;
- new-a = [
- new non-scanning-action $(source) : common.copy : $(properties) ] ;
+ new-a = [
+ new non-scanning-action $(source) : common.copy : $(properties) ] ;
local source-root = [ $(properties).get <install-source-root> ] ;
- if $(source-root)
- {
+ if $(source-root)
+ {
# Get the real path of the target. We probably need to strip
# relative path from the target name at construction...
local path = [ $(source).path ] ;
@@ -293,8 +294,8 @@
# path. The 'source-root' is already absolute, see the
# 'adjust-properties' method above.
path = [ path.root $(path) [ path.pwd ] ] ;
-
- relative = [ path.relative-to $(source-root) $(path) ] ;
+
+ relative = [ path.relative-to $(source-root) $(path) ] ;
# Note: using $(name:D=$(relative)) might be faster
# here, but then we need to explicitly check that
# relative is not ".", otherwise we might get paths like
@@ -302,190 +303,198 @@
# <prefix>/boost/.
#
# try to create it, and mkdir will obviously fail.
- name = [ path.root $(name:D=) $(relative) ] ;
- targets = [ new file-target $(name) exact : [ $(source).type ]
+ name = [ path.root $(name:D=) $(relative) ] ;
+ targets = [ new file-target $(name) exact : [ $(source).type ]
: $(project) : $(new-a) ] ;
-
- }
+ }
else
{
- targets = [ new file-target $(name:D=) exact : [ $(source).type ]
+ targets = [ new file-target $(name:D=) exact : [ $(source).type ]
: $(project) : $(new-a) ] ;
}
-
+
return $(targets) ;
}
+
rule symlink ( name : project : source : properties )
{
local a = [ new action $(source) : symlink.ln :
$(properties) ] ;
- local targets = [
+ local targets = [
new file-target $(name) exact : [ $(source).type ] : $(project) : $(a) ] ;
-
+
return $(targets) ;
}
-rule relink-file ( project : source : property-set )
-{
+
+rule relink-file ( project : source : property-set )
+{
local action = [ $(source).action ] ;
local cloned-action = [ virtual-target.clone-action $(action) : $(project) :
"" : $(property-set) ] ;
- local result = [ $(cloned-action).targets ] ;
-
+ local result = [ $(cloned-action).targets ] ;
+
return $(result) ;
}
+
# Declare installed version of the EXE type. Generator for this type will
# cause relinking to the new location.
type.register INSTALLED_EXE : : EXE ;
class installed-exe-generator : generator
{
- import type property-set modules stage ;
-
+ import type ;
+ import property-set ;
+ import modules ;
+ import stage ;
+
rule __init__ ( )
{
generator.__init__ install-exe : EXE : INSTALLED_EXE ;
}
-
+
rule run ( project name ? : property-set : source : multiple ? )
{
if [ $(property-set).get <os> ] in NT CYGWIN
{
# Relinking is never needed on NT
- return [ stage.copy-file $(project)
- : $(source) : $(property-set) ] ;
+ return [ stage.copy-file $(project)
+ : $(source) : $(property-set) ] ;
}
- else
+ else
{
- return [ stage.relink-file $(project)
- : $(source) : $(property-set) ] ;
- }
- }
+ return [ stage.relink-file $(project)
+ : $(source) : $(property-set) ] ;
+ }
+ }
}
generators.register [ new installed-exe-generator ] ;
# Installing shared link on Unix might cause a creation of
-# versioned symbolic links.
+# versioned symbolic links.
type.register INSTALLED_SHARED_LIB : : SHARED_LIB ;
+
class installed-shared-lib-generator : generator
{
- import type property-set modules stage ;
-
+ import type ;
+ import property-set ;
+ import modules ;
+ import stage ;
+
rule __init__ ( )
{
generator.__init__ install-shared-lib : SHARED_LIB
: INSTALLED_SHARED_LIB ;
}
-
+
rule run ( project name ? : property-set : source : multiple ? )
- {
+ {
if [ $(property-set).get <os> ] = NT
{
- local copied = [ stage.copy-file $(project)
- : $(source) : $(property-set) ] ;
-
+ local copied = [ stage.copy-file $(project)
+ : $(source) : $(property-set) ] ;
+
copied = [ virtual-target.register $(copied) ] ;
-
+
return $(copied) ;
}
- else
+ else
{
- local a = [ $(source).action ] ;
+ local a = [ $(source).action ] ;
local copied ;
if ! $(a)
{
# Non-derived file, just copy.
- copied = [ stage.copy-file $(project)
- : $(source) : $(property-set) ] ;
+ copied = [ stage.copy-file $(project)
+ : $(source) : $(property-set) ] ;
}
else
- {
+ {
local cp = [ $(a).properties ] ;
local current-dll-path = [ $(cp).get <dll-path> ] ;
local new-dll-path = [ $(property-set).get <dll-path> ] ;
-
+
if $(current-dll-path) != $(new-dll-path)
{
# Rpath changed, need to relink.
- copied = [ stage.relink-file
+ copied = [ stage.relink-file
$(project) : $(source) : $(property-set) ] ;
}
else
- {
- copied = [ stage.copy-file $(project)
- : $(source) : $(property-set) ] ;
+ {
+ copied = [ stage.copy-file $(project)
+ : $(source) : $(property-set) ] ;
}
}
-
+
copied = [ virtual-target.register $(copied) ] ;
-
+
local result = $(copied) ;
# If the name is in the form NNN.XXX.YYY.ZZZ, where all
# 'X', 'Y' and 'Z' are numbers, we need to create
# NNN.XXX and NNN.XXX.YYY symbolic links.
- local m = [ MATCH (.*)\\.([0123456789]+)\\.([0123456789]+)\\.([0123456789]+)$
+ local m = [ MATCH (.*)\\.([0123456789]+)\\.([0123456789]+)\\.([0123456789]+)$
: [ $(copied).name ] ] ;
if $(m)
{
# Symlink without version at all is used to make
# -lsome_library work.
result += [ stage.symlink $(m[1]) : $(project)
- : $(copied) : $(property-set) ] ;
-
+ : $(copied) : $(property-set) ] ;
+
# Symlinks of some libfoo.N and libfoo.N.M are used
# so that library can found at runtime, if libfoo.N.M.X
# has soname of libfoo.N. That happens when the library
# makes some binary compatibility guarantees. If not,
# it's possible to skip those symlinks.
- local suppress =
+ local suppress =
[ $(property-set).get <install-no-version-symlinks> ] ;
-
+
if $(suppress) != "on"
- {
+ {
result += [ stage.symlink $(m[1]).$(m[2]) : $(project)
: $(copied) : $(property-set) ] ;
result += [ stage.symlink $(m[1]).$(m[2]).$(m[3]) : $(project)
: $(copied) : $(property-set) ] ;
- }
+ }
}
-
+
return $(result) ;
- }
- }
+ }
+ }
}
generators.register [ new installed-shared-lib-generator ] ;
-
# Main target rule for 'install'
rule install ( name : sources * : requirements * : default-build * )
{
local project = [ project.current ] ;
-
+
# Unless the user has explicitly asked us to hardcode dll paths, add
# <hardcode-dll-paths>false in requirements, to override default
# value.
if ! <hardcode-dll-paths>true in $(requirements)
{
requirements += <hardcode-dll-paths>false ;
- }
-
+ }
+
if <tag> in $(requirements:G)
{
- errors.user-error
+ errors.user-error
"The <tag> property is not allowed for the 'install' rule" ;
}
-
+
targets.main-target-alternative
- [ new install-target-class $(name) : $(project)
+ [ new install-target-class $(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-requirements $(requirements) : $(project) ]
+ : [ targets.main-target-default-build $(default-build) : $(project) ]
] ;
}