|
|
Boost-Commit : |
From: jurko.gospodnetic_at_[hidden]
Date: 2008-05-01 11:09:59
Author: jurko
Date: 2008-05-01 11:09:58 EDT (Thu, 01 May 2008)
New Revision: 44975
URL: http://svn.boost.org/trac/boost/changeset/44975
Log:
Boost Build comment typo corrections and minor stylistic changes.
Text files modified:
trunk/tools/build/v2/build/alias.jam | 29 ++++-----
trunk/tools/build/v2/build/targets.jam | 106 ++++++++++++++++++++++-----------
trunk/tools/build/v2/build/virtual-target.jam | 65 +++++++++++++++-----
trunk/tools/build/v2/tools/builtin.jam | 6
trunk/tools/build/v2/tools/common.jam | 46 ++++++++++----
trunk/tools/build/v2/tools/make.jam | 58 ++++++++---------
trunk/tools/build/v2/util/path.jam | 127 ++++++++++++++++++++-------------------
7 files changed, 260 insertions(+), 177 deletions(-)
Modified: trunk/tools/build/v2/build/alias.jam
==============================================================================
--- trunk/tools/build/v2/build/alias.jam (original)
+++ trunk/tools/build/v2/build/alias.jam 2008-05-01 11:09:58 EDT (Thu, 01 May 2008)
@@ -2,27 +2,26 @@
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
-# This module defines the 'alias' rule and the associated target class.
+# This module defines the 'alias' rule and the associated target class.
#
-# Alias is just a main target which returns its source targets without any
-# processing. For example:
+# Alias is just a main target which returns its source targets without any
+# processing. For example:
#
-# alias bin : hello test_hello ;
-# alias lib : helpers xml_parser ;
+# alias bin : hello test_hello ;
+# alias lib : helpers xml_parser ;
#
-# Another important use of 'alias' is to conveniently group source files:
+# Another important use of 'alias' is to conveniently group source files:
#
-# alias platform-src : win.cpp : <os>NT ;
-# alias platform-src : linux.cpp : <os>LINUX ;
-# exe main : main.cpp platform-src ;
+# alias platform-src : win.cpp : <os>NT ;
+# alias platform-src : linux.cpp : <os>LINUX ;
+# exe main : main.cpp platform-src ;
#
-# Lastly, it's possible to create local alias for some target, with different
-# properties::
+# Lastly, it is possible to create local alias for some target, with different
+# properties:
#
-# alias big_lib : : @/external_project/big_lib/<link>static ;
+# alias big_lib : : @/external_project/big_lib/<link>static ;
#
-
import "class" : new ;
import project ;
import property-set ;
@@ -53,6 +52,7 @@
}
# Declares the 'alias' target. It will build sources, and return them unaltered.
+#
rule alias ( name : sources * : requirements * : default-build * : usage-requirements * )
{
local project = [ project.current ] ;
@@ -67,6 +67,3 @@
}
IMPORT $(__name__) : alias : : alias ;
-
-
-
Modified: trunk/tools/build/v2/build/targets.jam
==============================================================================
--- trunk/tools/build/v2/build/targets.jam (original)
+++ trunk/tools/build/v2/build/targets.jam 2008-05-01 11:09:58 EDT (Thu, 01 May 2008)
@@ -5,29 +5,28 @@
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
-# Supports 'abstract' targets, which are targets explicitly defined in a
-# Jamfile.
+# Supports 'abstract' targets, which are targets explicitly defined in a
+# Jamfile.
#
-# Abstract targets are represented by classes derived from 'abstract-target'
-# class. The first abstract target is 'project-target', which is created for
-# each Jamfile, and can be obtained by the 'target' rule in the Jamfile's
-# module (see project.jam).
-#
-# Project targets keep a list of 'main-target' instances. A main target is
-# what the user explicitly defines in a Jamfile. It is possible to have
-# several definitions for a main target, for example to have different lists
-# of sources for different platforms. So, main targets keep a list of
-# alternatives.
-#
-# Each alternative is an instance of 'abstract-target'. When a main target
-# subvariant is defined by some rule, that rule will decide what class to use,
-# create an instance of that class and add it to the list of alternatives for
-# the main target.
-#
-# Rules supplied by the build system will use only targets derived from
-# 'basic-target' class, which will provide some default behaviour. There will
-# be different classes derived from it such as 'make-target', created by the
-# 'make' rule, and 'typed-target', created by rules such as 'exe' and 'lib'.
+# Abstract targets are represented by classes derived from 'abstract-target'
+# class. The first abstract target is 'project-target', which is created for
+# each Jamfile, and can be obtained by the 'target' rule in the Jamfile's module
+# (see project.jam).
+#
+# Project targets keep a list of 'main-target' instances. A main target is
+# what the user explicitly defines in a Jamfile. It is possible to have several
+# definitions for a main target, for example to have different lists of sources
+# for different platforms. So, main targets keep a list of alternatives.
+#
+# Each alternative is an instance of 'abstract-target'. When a main target
+# subvariant is defined by some rule, that rule will decide what class to use,
+# create an instance of that class and add it to the list of alternatives for
+# the main target.
+#
+# Rules supplied by the build system will use only targets derived from
+# 'basic-target' class, which will provide some default behaviour. There will be
+# different classes derived from it such as 'make-target', created by the 'make'
+# rule, and 'typed-target', created by rules such as 'exe' and 'lib'.
#
# +------------------------+
@@ -80,7 +79,9 @@
import set ;
import toolset ;
+
# Base class for all abstract targets.
+#
class abstract-target
{
import project ;
@@ -135,6 +136,7 @@
# - a list of produced virtual targets, which may be empty.
# If 'property-set' is empty, performs the default build of this target, in
# a way specific to the derived class.
+ #
rule generate ( property-set )
{
errors.error "method should be defined in derived classes" ;
@@ -181,6 +183,7 @@
# that time, alternatives can also be renamed to account for inline targets.
# - The first time 'main-target' or 'has-main-target' rule is called, all
# alternatives are enumerated and main targets are created.
+#
class project-target : abstract-target
{
import project ;
@@ -211,6 +214,7 @@
# This is needed only by the 'make' rule. Need to find the way to make
# 'make' work without this method.
+ #
rule project-module ( )
{
return $(self.project-module) ;
@@ -238,6 +242,7 @@
}
# Generates all possible targets contained in this project.
+ #
rule generate ( property-set * )
{
if [ modules.peek : .debug-building ]
@@ -261,6 +266,7 @@
# Computes and returns a list of abstract-target instances which must be
# built when this project is built.
+ #
rule targets-to-build ( )
{
local result ;
@@ -291,6 +297,7 @@
# Add 'target' to the list of targets in this project that should be build
# only by explicit request
+ #
rule mark-target-as-explicit ( target-name )
{
# Record the name of the target, not instance, since this
@@ -299,6 +306,7 @@
}
# Add new target alternative
+ #
rule add-alternative ( target-instance )
{
if $(self.built-main-targets)
@@ -310,6 +318,7 @@
}
# Returns a 'main-target' class instance corresponding to the 'name'.
+ #
rule main-target ( name )
{
if ! $(self.built-main-targets)
@@ -321,6 +330,7 @@
}
# Tells if a main target with the specified name exists.
+ #
rule has-main-target ( name )
{
if ! $(self.built-main-targets)
@@ -334,8 +344,9 @@
}
}
- # Find and return the target with the specified id, treated
- # relative to self.
+ # Find and return the target with the specified id, treated relative to
+ # self.
+ #
rule find-really ( id )
{
local result ;
@@ -452,6 +463,7 @@
}
# Accessor, add a constant.
+ #
rule add-constant (
name # Variable name of the constant.
: value + # Value of the constant.
@@ -506,7 +518,8 @@
}
-# Helper rules to detect cycles in main target references
+# Helper rules to detect cycles in main target references.
+#
local rule start-building ( main-target-instance )
{
if $(main-target-instance) in $(.targets-being-built)
@@ -532,6 +545,7 @@
# A named top-level target in Jamfile.
+#
class main-target : abstract-target
{
import assert ;
@@ -568,6 +582,7 @@
# Returns the best viable alternative for this property-set. See the
# documentation for selection rules.
+ #
local rule select-alternatives ( property-set debug ? )
{
# When selecting alternatives we have to consider defaults, for example:
@@ -697,8 +712,9 @@
# Select an alternative for this main target, by finding all alternatives
# which requirements are satisfied by 'properties' and picking the one with
- # longest requirements set. Returns the result of calling 'generate' on that
- # alternative.
+ # the longest requirements set. Returns the result of calling 'generate' on
+ # that alternative.
+ #
rule generate ( property-set )
{
start-building $(__name__) ;
@@ -726,7 +742,8 @@
# 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.
+ # It is possible that no targets are generated.
+ #
local rule generate-really ( property-set )
{
local best-alternatives = [ select-alternatives $(property-set) ] ;
@@ -757,6 +774,7 @@
# Abstract target which refers to a source file. This is an artificial entity
# allowing sources to a target to be represented using a list of abstract target
# instances.
+#
class file-reference : abstract-target
{
import virtual-target ;
@@ -811,6 +829,7 @@
# Given a target-reference, made in context of 'project', returns the
# abstract-target instance that is referred to, as well as properties explicitly
# specified for this reference.
+#
rule resolve-reference ( target-reference : project )
{
# Separate target name from properties override
@@ -834,6 +853,7 @@
# both to a main target or to a file. Returns a list consisting of
# - usage requirements
# - generated virtual targets, if any
+#
rule generate-from-reference (
target-reference # Target reference.
: project # Project where the reference is made.
@@ -861,6 +881,7 @@
# Given a 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 a
@@ -891,6 +912,7 @@
#
# If 'what' is 'refined' returns context refined with new requirements. If
# 'what' is 'added' returns just the requirements to be applied.
+#
rule evaluate-requirements ( requirements : context : what )
{
# Apply non-conditional requirements. It's possible that further conditional
@@ -1007,6 +1029,7 @@
# 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 ;
@@ -1051,6 +1074,7 @@
# Returns the list of abstract-targets which are used as sources. The extra
# properties specified for sources are not represented. The only user for
# this rule at the moment is the "--dump-tests" feature of the test system.
+ #
rule sources ( )
{
if ! $(self.source-targets) {
@@ -1075,16 +1099,16 @@
# 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
+ # The condition is composed of all base non-conditional properties. It
+ # is not clear if we should expand 'self.requirements' or not. For one
# thing, it would be nice to be able to put
# <toolset>msvc-6.0
- # in requirements.
- # On the other hand, if we have <variant>release in condition it does
- # not make sense to require <optimization>full to be in build request
- # just to select this variant.
+ # in requirements. On the other hand, if we have <variant>release as a
+ # condition it does not make sense to require <optimization>full to be
+ # in the build request just to select this variant.
local bcondition = [ $(self.requirements).base ] ;
local ccondition = [ $(self.requirements).conditional ] ;
local condition = [ set.difference $(bcondition) : $(ccondition) ] ;
@@ -1116,6 +1140,7 @@
#
# The results are added to the variable called 'result-var'. Usage
# requirements are added to the variable called 'usage-requirements-var'.
+ #
rule generate-dependencies ( dependencies * : property-set
: result-var usage-requirements-var )
{
@@ -1135,6 +1160,7 @@
# Determines final build properties, generates sources, and calls
# 'construct'. This method should not be overridden.
+ #
rule generate ( property-set )
{
if [ modules.peek : .debug-building ]
@@ -1267,6 +1293,7 @@
# 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 ] ;
@@ -1309,6 +1336,7 @@
# 'root-targets' - virtual targets to be returned to dependants
# 'all-targets' - virtual targets created while building this main target
# 'build-request' - property-set instance with requested build properties
+ #
local rule create-subvariant ( root-targets *
: all-targets * : build-request : sources * : rproperties
: usage-requirements )
@@ -1333,8 +1361,9 @@
}
# Constructs virtual targets for this abstract target and the dependency
- # graph. Returns the list of virtual targets. Should be overriden in derived
- # classes.
+ # graph. Returns a usage-requirements property-set and a list of virtual
+ # targets. Should be overriden in derived classes.
+ #
rule construct ( name : source-targets * : properties * )
{
errors.error "method should be defined in derived classes" ;
@@ -1423,6 +1452,7 @@
# Returns the requirements to use when declaring a main target, obtained by
# translating all specified property paths and refining project requirements
# with the ones specified for the target.
+#
rule main-target-requirements (
specification * # Properties explicitly specified for the main target.
: project # Project where the main target is to be declared.
@@ -1444,6 +1474,7 @@
# Returns the usage requirements to use when declaring a main target, which are
# obtained by translating all specified property paths and adding project's
# usage requirements.
+#
rule main-target-usage-requirements (
specification * # Use-properties explicitly specified for a main target.
: project # Project where the main target is to be declared.
@@ -1466,6 +1497,7 @@
# 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.
@@ -1485,6 +1517,7 @@
# Registers the specified target as a main target alternative and returns it.
+#
rule main-target-alternative ( target )
{
local ptarget = [ $(target).project ] ;
@@ -1496,6 +1529,7 @@
# 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 * )
{
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-05-01 11:09:58 EDT (Thu, 01 May 2008)
@@ -4,10 +4,10 @@
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
-# Implements virtual targets, which correspond to actual files created during
-# a build, but are not yet targets in Jam sense. They are needed, for example,
-# when searching for possible transormation sequences, when it's not yet known
-# whether a particular target should be created at all.
+# Implements virtual targets, which correspond to actual files created during a
+# build, but are not yet targets in Jam sense. They are needed, for example,
+# when searching for possible transformation sequences, when it's not yet known
+# whether a particular target should be created at all.
import "class" : new ;
import errors ;
@@ -64,6 +64,7 @@
# The 'compile-action' and 'link-action' classes are not defined here but in
# builtin.jam modules. They are shown in the diagram to give the big picture.
+
# Models a potential target. It can be converted into a Jam target and used in
# building, if needed. However, it can be also dropped, which allows us to
# search for different transformations and select only one.
@@ -86,12 +87,15 @@
}
# Name of this target.
+ #
rule name ( ) { return $(self.name) ; }
# Project of this target.
+ #
rule project ( ) { return $(self.project) ; }
# Adds additional 'virtual-target' instances this one depends on.
+ #
rule depends ( d + )
{
self.dependencies = [ sequence.merge $(self.dependencies)
@@ -113,6 +117,7 @@
# file if 'scanner' is specified.
#
# If scanner is not specified then the actual target is returned.
+ #
rule actualize ( scanner ? )
{
local actual-name = [ actualize-no-scanner ] ;
@@ -146,12 +151,14 @@
# Sets up build actions for 'target'. Should call appropriate rules and set
# target variables.
+ #
rule actualize-action ( target )
{
errors.error "method should be defined in derived classes" ;
}
# Sets up variables on 'target' which specify its location.
+ #
rule actualize-location ( target )
{
errors.error "method should be defined in derived classes" ;
@@ -159,6 +166,7 @@
# If the target is a generated one, returns the path where it will be
# generated. Otherwise, returns an empty list.
+ #
rule path ( )
{
errors.error "method should be defined in derived classes" ;
@@ -166,6 +174,7 @@
# Returns the actual target name to be used in case when no scanner is
# involved.
+ #
rule actual-name ( )
{
errors.error "method should be defined in derived classes" ;
@@ -175,8 +184,8 @@
rule actualize-no-scanner ( )
{
# In fact, we just need to merge virtual-target with
- # abstract-virtual-target as the latter is the only class derived from
- # the former. But that's for later.
+ # abstract-file-target as the latter is the only class derived from the
+ # former. But that's for later.
errors.error "method should be defined in derived classes" ;
}
}
@@ -190,6 +199,7 @@
#
# The target's grist is concatenation of its project's location, properties of
# action (for derived files) and, optionally, value identifying the main target.
+#
class abstract-file-target : virtual-target
{
import project ;
@@ -230,12 +240,14 @@
# Sets the path. When generating target name, it will override any path
# computation from properties.
+ #
rule set-path ( path )
{
self.path = [ path.native $(path) ] ;
}
# Returns the currently set action.
+ #
rule action ( )
{
return $(self.action) ;
@@ -243,6 +255,7 @@
# Sets/gets the 'root' flag. Target is root if it directly corresponds to
# some variant of a main target.
+ #
rule root ( set ? )
{
if $(set)
@@ -256,9 +269,10 @@
# when target is brought into existance and is never changed after that. In
# particular, if a target is shared by a subvariant, only the first is
# stored.
- rule creating-subvariant ( s ? # If specified, specifies the value to set,
- # which should be a 'subvariant' class
- # instance.
+ #
+ rule creating-subvariant ( s ? # If specified, specifies the value to set,
+ # which should be a 'subvariant' class
+ # instance.
)
{
if $(s) && ! $(self.creating-subvariant) && ! $(overwrite)
@@ -333,7 +347,6 @@
local grist = [ grist ] ;
local basename = [ path.native $(self.name) ] ;
self.actual-name = <$(grist)>$(basename) ;
-
}
return $(self.actual-name) ;
}
@@ -341,6 +354,7 @@
# Helper to 'actual-name', above. Computes a unique prefix used to
# distinguish this target from other targets with the same name creating
# different files.
+ #
rule grist ( )
{
# Depending on target, there may be different approaches to generating
@@ -379,11 +393,12 @@
# Given the target name specified in constructor, returns the name which
# should be really used, by looking at the <tag> properties. Tag properties
- # need to be specified as <tag>@rule-name. This makes Boost.Build call the
+ # need to be specified as <tag>@rule-name. This makes Boost Build call the
# specified rule with the target name, type and properties to get the new
# name. If no <tag> property is specified or the rule specified by <tag>
# returns nothing, returns the result of calling
# virtual-target.add-prefix-and-suffix.
+ #
rule _adjust-name ( specified-name )
{
local ps ;
@@ -468,6 +483,7 @@
# 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) ] ;
@@ -546,7 +562,7 @@
DEPENDS $(target) : $(path) ;
common.MkDir $(path) ;
- # It's possible that the target name includes a directory too, for
+ # It is possible that the target name includes a directory too, for
# example when installing headers. Create that directory.
if $(target:D)
{
@@ -584,6 +600,7 @@
}
# Returns the directory for this target.
+ #
rule path ( )
{
if ! $(self.path)
@@ -616,6 +633,7 @@
}
# Returns nothing to indicate that the target's path is not known.
+ #
rule path ( )
{
return ;
@@ -635,7 +653,7 @@
# rule action-name ( targets + : sources * : properties * )
# Targets and sources are passed as actual Jam targets. The rule may not
# establish additional dependency relationships.
-
+#
class action
{
import "class" ;
@@ -691,6 +709,7 @@
}
# Generates actual build instructions.
+ #
rule actualize ( )
{
if ! $(self.actualized)
@@ -733,6 +752,7 @@
# Helper for 'actualize-sources'. For each passed source, actualizes it with
# the appropriate scanner. Returns the actualized virtual targets.
+ #
rule actualize-source-type ( sources * : property-set )
{
local result = ;
@@ -756,6 +776,7 @@
#
# New values will be *appended* to the variables. They may be non-empty if
# caller wants it.
+ #
rule actualize-sources ( sources * : property-set )
{
local dependencies = [ $(self.properties).get <dependency> ] ;
@@ -786,6 +807,7 @@
# the last chance to fix properties, for example to adjust includes to get
# generated headers correctly. Default implementation simply returns its
# argument.
+ #
rule adjust-properties ( property-set )
{
return $(property-set) ;
@@ -797,6 +819,7 @@
# properties out of nowhere. It's needed to distinguish virtual targets with
# different properties that are known to exist and have no actions which create
# them.
+#
class null-action : action
{
rule __init__ ( property-set ? )
@@ -820,6 +843,7 @@
# Class which acts exactly like 'action', except that its sources are not
# scanned for dependencies.
+#
class non-scanning-action : action
{
rule __init__ ( sources * : action-name + : property-set ? )
@@ -846,6 +870,7 @@
# name and source location for the project, and use that path to determine if
# the target was already created.
# TODO: passing a project with all virtual targets is starting to be annoying.
+#
rule from-file ( file : file-loc : project )
{
import type ; # Had to do this here to break a circular dependency.
@@ -880,6 +905,7 @@
# same sources and equal action. If such target is found it is returned and a
# new 'target' is not registered. Otherwise, 'target' is registered and
# returned.
+#
rule register ( target )
{
local signature = [ sequence.join
@@ -905,9 +931,9 @@
{
local ps1 = [ $(a1).properties ] ;
local ps2 = [ $(a2).properties ] ;
- local p1 = [ $(ps1).base ] [ $(ps1).free ]
+ local p1 = [ $(ps1).base ] [ $(ps1).free ]
[ set.difference [ $(ps1).dependency ] : [ $(ps1).incidental ] ] ;
- local p2 = [ $(ps2).base ] [ $(ps2).free ]
+ local p2 = [ $(ps2).base ] [ $(ps2).free ]
[ set.difference [ $(ps2).dependency ] : [ $(ps2).incidental ] ] ;
if $(p1) = $(p2)
{
@@ -934,6 +960,7 @@
# Each target returned by 'register' is added to a recent-targets list, returned
# by this function. 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) ;
@@ -947,6 +974,7 @@
# Returns all virtual targets ever created.
+#
rule all-targets ( )
{
return $(.all-targets) ;
@@ -955,6 +983,7 @@
# Returns all targets from 'targets' with types equal to 'type' or derived from
# it.
+#
rule select-by-type ( type : targets * )
{
local result ;
@@ -1013,6 +1042,7 @@
# found during traversal, it's either included or not, depending on the value of
# 'include-roots'. In either case traversal stops at root targets, i.e. sources
# of root targets are not traversed.
+#
rule traverse ( target : include-roots ? : include-sources ? )
{
local result ;
@@ -1046,6 +1076,7 @@
# 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)
@@ -1059,7 +1090,7 @@
local action-class = [ modules.peek $(action) : __class__ ] ;
local cloned-action = [ class.new $(action-class)
- [ $(action).sources ] : $(new-action-name) : $(new-properties) ] ;
+ [ $(action).sources ] : $(new-action-name) : $(new-properties) ] ;
local cloned-targets ;
for local target in [ $(action).targets ]
@@ -1151,6 +1182,7 @@
# 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.
@@ -1179,6 +1211,7 @@
# referred by <implcit-dependecy> properties. For all targets of type
# 'target-type' (or for all targets, if 'target-type' is not specified), the
# result will contain <$(feature)>path-to-that-target.
+ #
rule implicit-includes ( feature : target-type ? )
{
local key = ii$(feature)-$(target-type:E="") ;
Modified: trunk/tools/build/v2/tools/builtin.jam
==============================================================================
--- trunk/tools/build/v2/tools/builtin.jam (original)
+++ trunk/tools/build/v2/tools/builtin.jam 2008-05-01 11:09:58 EDT (Thu, 01 May 2008)
@@ -449,9 +449,9 @@
# which is handled specifically.
type.set-scanner CPP : c-scanner ;
type.set-scanner C : c-scanner ;
-# One case where scanning of H/HPP files is necessary is PCH generation --
-# if any header included by HPP being precompiled changes, we need to
-# recompile the header.
+# One case where scanning of H/HPP files is necessary is PCH generation -- if
+# any header included by HPP being precompiled changes, we need to recompile the
+# header.
type.set-scanner H : c-scanner ;
type.set-scanner HPP : c-scanner ;
Modified: trunk/tools/build/v2/tools/common.jam
==============================================================================
--- trunk/tools/build/v2/tools/common.jam (original)
+++ trunk/tools/build/v2/tools/common.jam 2008-05-01 11:09:58 EDT (Thu, 01 May 2008)
@@ -63,6 +63,7 @@
#
# Returns 'true' if the configuration has been added and an empty value if
# it already exists. Reports an error if the configuration is 'used'.
+ #
rule register ( id )
{
if $(id) in $(self.used)
@@ -88,6 +89,7 @@
# Returns 'true' if the state of the configuration has been changed to
# 'used' and an empty value if it the state wasn't changed. Reports an error
# if the configuration isn't known.
+ #
rule use ( id )
{
if ! $(id) in $(self.all)
@@ -109,24 +111,28 @@
}
# Return all registered configurations.
+ #
rule all ( )
{
return $(self.all) ;
}
# Return all used configurations.
+ #
rule used ( )
{
return $(self.used) ;
}
# Returns the value of a configuration parameter.
+ #
rule get ( id : param )
{
return $(self.$(param).$(id)) ;
}
# Sets the value of a configuration parameter.
+ #
rule set ( id : param : value * )
{
self.$(param).$(id) = $(value) ;
@@ -140,11 +146,12 @@
# will check that the combination of all parameter values is unique in all
# invocations.
#
-# Each parameter name corresponds to a subfeature. This rule will declare
-# a subfeature the first time a non-empty parameter value is passed and will
+# Each parameter name corresponds to a subfeature. This rule will declare a
+# subfeature the first time a non-empty parameter value is passed and will
# extend it with all the values.
#
# The return value from this rule is a condition to be used for flags settings.
+#
rule check-init-parameters ( toolset requirement * : * )
{
local sig = $(toolset) ;
@@ -251,6 +258,7 @@
# This rule returns the command to be used when invoking the tool. If we can't
# find the tool, a warning is issued. If 'path-last' is specified, PATH is
# checked after 'additional-paths' when searching for 'tool'.
+#
rule get-invocation-command-nodefault (
toolset : tool : user-provided-command * : additional-paths * : path-last ? )
{
@@ -281,6 +289,7 @@
# Same as get-invocation-command-nodefault, except that if no tool is found,
# returns either the user-provided-command, if present, or the 'tool' parameter.
+#
rule get-invocation-command (
toolset : tool : user-provided-command * : additional-paths * : path-last ? )
{
@@ -304,6 +313,7 @@
# Given an invocation command return the absolute path to the command. This
# works even if command has no path element and was found on the PATH.
+#
rule get-absolute-tool-path ( command )
{
if $(command:D)
@@ -323,6 +333,7 @@
# absolute name. If the tool is found in several directories, returns all paths.
# Otherwise, returns an empty string. If 'path-last' is specified, PATH is
# searched after 'additional-paths'.
+#
rule find-tool ( name : additional-paths * : path-last ? )
{
local path = [ path.programs-path ] ;
@@ -358,6 +369,7 @@
# Checks if 'command' can be found either in path or is a full name to an
# existing file.
+#
rule check-tool-aux ( command )
{
if $(command:D)
@@ -384,6 +396,7 @@
# Checks that a tool can be invoked by 'command'. If command is not an absolute
# path, checks if it can be found in 'path'. If comand is an absolute path,
# check that it exists. Returns 'command' if ok or empty string otherwise.
+#
rule check-tool ( xcommand + )
{
if [ check-tool-aux $(xcommand[1]) ] ||
@@ -399,8 +412,9 @@
# - CONFIG_COMMAND to 'command'
# - OPTIONS for compile.c to the value of <cflags> in options
# - OPTIONS for compile.c++ to the value of <cxxflags> in options
-# - OPTIOns for compile to the value of <compileflags> in options
-# - OPTIONs for link to the value of <linkflags> in options
+# - OPTIONS for compile to the value of <compileflags> in options
+# - OPTIONS for link to the value of <linkflags> in options
+#
rule handle-options ( toolset : condition * : command * : options * )
{
if $(.debug-configuration)
@@ -411,19 +425,20 @@
# The last parameter ('true') says it's OK to set flags for another module.
toolset.flags $(toolset) CONFIG_COMMAND $(condition) : $(command) : unchecked ;
toolset.flags $(toolset).compile OPTIONS $(condition) :
- [ feature.get-values <compileflags> : $(options) ] : unchecked ;
+ [ feature.get-values <compileflags> : $(options) ] : unchecked ;
toolset.flags $(toolset).compile.c OPTIONS $(condition) :
- [ feature.get-values <cflags> : $(options) ] : unchecked ;
+ [ feature.get-values <cflags> : $(options) ] : unchecked ;
toolset.flags $(toolset).compile.c++ OPTIONS $(condition) :
- [ feature.get-values <cxxflags> : $(options) ] : unchecked ;
+ [ feature.get-values <cxxflags> : $(options) ] : unchecked ;
toolset.flags $(toolset).compile.fortran OPTIONS $(condition) :
- [ feature.get-values <fflags> : $(options) ] : unchecked ;
+ [ feature.get-values <fflags> : $(options) ] : unchecked ;
toolset.flags $(toolset).link OPTIONS $(condition) :
- [ feature.get-values <linkflags> : $(options) ] : unchecked ;
+ [ feature.get-values <linkflags> : $(options) ] : unchecked ;
}
-# Returns the location of the "program files" directory on a windows platform.
+# Returns the location of the "program files" directory on a Windows platform.
+#
rule get-program-files-dir ( )
{
local ProgramFiles = [ modules.peek : ProgramFiles ] ;
@@ -471,6 +486,7 @@
# visible in the environment seen by subsequently executed commands. In other
# words, on Unix systems, the variable is exported, which is consistent with the
# only possible behavior on Windows systems.
+#
rule variable-setting-command ( variable : value )
{
local nl = "
@@ -489,6 +505,7 @@
# Returns a command to sets a named shell path variable to the given NATIVE
# paths on the current platform.
+#
rule path-variable-setting-command ( variable : paths * )
{
local sep = [ os.path-separator ] ;
@@ -498,6 +515,7 @@
# Returns a command that prepends the given paths to the named path variable on
# the current platform.
+#
rule prepend-path-variable-command ( variable : paths * )
{
return [ path-variable-setting-command $(variable)
@@ -508,6 +526,7 @@
# Return a command which can create a file. If 'r' is result of invocation, then
# 'r foobar' will create foobar with unspecified content. What happens if file
# already exists is unspecified.
+#
rule file-creation-command ( )
{
if [ modules.peek : NT ]
@@ -524,6 +543,7 @@
# Returns a command that may be used for 'touching' files. It is not a real
# 'touch' command on NT because it adds an empty line at the end of file but it
# works with source files.
+#
rule file-touch-command ( )
{
if [ os.name ] in NT
@@ -550,7 +570,7 @@
$(<)-mkdir = true ;
MkDir1 $(<) ;
- Depends dirs : $(<) ;
+ DEPENDS dirs : $(<) ;
# Recursively make parent directories.
# $(<:P) = $(<)'s parent, & we recurse until root
@@ -568,7 +588,7 @@
if $(s) && $(s) != $(<)
{
- Depends $(<) : $(s) ;
+ DEPENDS $(<) : $(s) ;
MkDir $(s) ;
}
else if $(s)
@@ -703,7 +723,7 @@
result += [ join-tag $(f:G=) : $(p) ] ;
}
}
-
+
case * :
result += $(f:G=) ;
}
Modified: trunk/tools/build/v2/tools/make.jam
==============================================================================
--- trunk/tools/build/v2/tools/make.jam (original)
+++ trunk/tools/build/v2/tools/make.jam 2008-05-01 11:09:58 EDT (Thu, 01 May 2008)
@@ -1,9 +1,9 @@
-# Copyright 2003 Dave Abrahams
-# Copyright 2003 Douglas Gregor
-# Copyright 2006 Rene Rivera
-# Copyright 2002, 2003, 2004, 2005, 2006 Vladimir Prus
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+# Copyright 2003 Dave Abrahams
+# Copyright 2003 Douglas Gregor
+# Copyright 2006 Rene Rivera
+# Copyright 2002, 2003, 2004, 2005, 2006 Vladimir Prus
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
# This module defines the 'make' main target rule.
@@ -16,58 +16,56 @@
import property-set ;
import project ;
+
class make-target-class : basic-target
{
- import type regex virtual-target ;
+ import type regex virtual-target ;
import "class" : new ;
-
+
rule __init__ ( name : project : sources * : requirements *
: default-build * : usage-requirements * )
- {
- basic-target.__init__ $(name) : $(project) : $(sources)
+ {
+ basic-target.__init__ $(name) : $(project) : $(sources)
: $(requirements) : $(default-build) : $(usage-requirements) ;
}
-
+
rule construct ( name : source-targets * : property-set )
{
- local action-name = [ $(property-set).get <action> ] ;
- # 'm' will always be set -- we add '@' outselfs in 'make'
- # rule below.
+ local action-name = [ $(property-set).get <action> ] ;
+ # 'm' will always be set -- we add '@' ourselves in 'make' rule below.
local m = [ MATCH ^@(.*) : $(action-name) ] ;
-
+
local a = [ new action $(source-targets) : $(m[1])
- : $(property-set) ] ;
- local t = [ new file-target $(self.name) exact
- : [ type.type $(self.name) ] : $(self.project) : $(a) ] ;
+ : $(property-set) ] ;
+ local t = [ new file-target $(self.name) exact
+ : [ type.type $(self.name) ] : $(self.project) : $(a) ] ;
return [ property-set.empty ] [ virtual-target.register $(t) ] ;
- }
+ }
}
# Declares the 'make' main target.
+#
rule make ( target-name : sources * : generating-rule + : requirements *
: usage-requirements * )
{
local project = [ project.current ] ;
-
- # The '@' sign causes the feature.jam module to qualify rule name
- # with the module name of current project, if needed.
+
+ # The '@' sign causes the feature.jam module to qualify rule name with the
+ # module name of current project, if needed.
local m = [ MATCH ^(@).* : $(generating-rule) ] ;
if ! $(m)
{
generating-rule = @$(generating-rule) ;
- }
+ }
requirements += <action>$(generating-rule) ;
-
+
targets.main-target-alternative
[ new make-target-class $(target-name) : $(project)
- : [ targets.main-target-sources $(sources) : $(target-name) ]
- : [ targets.main-target-requirements $(requirements) : $(project) ]
- : [ targets.main-target-default-build : $(project) ]
+ : [ targets.main-target-sources $(sources) : $(target-name) ]
+ : [ targets.main-target-requirements $(requirements) : $(project) ]
+ : [ targets.main-target-default-build : $(project) ]
: [ targets.main-target-usage-requirements $(usage-requirements) : $(project) ]
] ;
-
}
IMPORT $(__name__) : make : : make ;
-
-
Modified: trunk/tools/build/v2/util/path.jam
==============================================================================
--- trunk/tools/build/v2/util/path.jam (original)
+++ trunk/tools/build/v2/util/path.jam 2008-05-01 11:09:58 EDT (Thu, 01 May 2008)
@@ -6,16 +6,16 @@
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
-# Performs various path manipulations. Paths are always in a 'normalized'
-# representation. In it, a path may be either:
+# Performs various path manipulations. Paths are always in a 'normalized'
+# representation. In it, a path may be either:
#
# - '.', or
#
-# - ['/'] [ ( '..' '/' )* (token '/')* token ]
+# - ['/'] [ ( '..' '/' )* (token '/')* token ]
#
-# In plain english, path can be rooted, '..' elements are allowed only
-# at the beginning, and it never ends in slash, except for path consisting
-# of slash only.
+# In plain english, path can be rooted, '..' elements are allowed only at the
+# beginning, and it never ends in slash, except for path consisting of slash
+# only.
import errors ;
import modules ;
@@ -35,7 +35,7 @@
}
}
-# Converts the native path into normalized form.
+# Converts the native path into normalized form.
#
rule make ( native )
{
@@ -43,7 +43,7 @@
}
-# Builds native representation of the path.
+# Builds native representation of the path.
#
rule native ( path )
{
@@ -51,7 +51,7 @@
}
-# Tests if a path is rooted.
+# Tests if a path is rooted.
#
rule is-rooted ( path )
{
@@ -59,7 +59,7 @@
}
-# Tests if a path has a parent.
+# Tests if a path has a parent.
#
rule has-parent ( path )
{
@@ -74,7 +74,7 @@
}
-# Returns the path without any directory components.
+# Returns the path without any directory components.
#
rule basename ( path )
{
@@ -82,7 +82,7 @@
}
-# Returns parent directory of the path. If no parent exists, error is issued.
+# Returns parent directory of the path. If no parent exists, error is issued.
#
rule parent ( path )
{
@@ -94,8 +94,8 @@
}
else
{
- # Strip everything at the end of path up to and including
- # the last slash
+ # Strip everything at the end of path up to and including the last
+ # slash.
local result = [ regex.match "((.*)/)?([^/]+)" : $(path) : 2 3 ] ;
# Did we strip what we shouldn't?
@@ -127,8 +127,8 @@
}
-# Returns path2 such that "[ join path path2 ] = .".
-# The path may not contain ".." element or be rooted.
+# Returns path2 such that "[ join path path2 ] = .". The path may not contain
+# ".." element or be rooted.
#
rule reverse ( path )
{
@@ -150,8 +150,8 @@
# Auxillary rule: does all the semantic of 'join', except for error cheching.
-# The error checking is separated because this rule is recursive, and I don't
-# like the idea of checking the same input over and over.
+# The error checking has been separated because this rule is recursive, and I
+# do not like the idea of checking the same input over and over.
#
local rule join-imp ( elements + )
{
@@ -168,8 +168,8 @@
}
-# Contanenates the passed path elements. Generates an error if
-# any element other than the first one is rooted.
+# Concatenates the passed path elements. Generates an error if any element other
+# than the first one is rooted.
#
rule join ( elements + )
{
@@ -191,7 +191,7 @@
}
-# If 'path' is relative, it is rooted at 'root'. Otherwise, it's unchanged.
+# If 'path' is relative, it is rooted at 'root'. Otherwise, it's unchanged.
#
rule root ( path root )
{
@@ -203,7 +203,7 @@
}
-# Returns the current working directory.
+# Returns the current working directory.
#
rule pwd ( )
{
@@ -219,19 +219,20 @@
}
-# Returns the list of files matching the given pattern in the
-# specified directory. Both directories and patterns are
-# supplied as portable paths. Each pattern should be non-absolute
-# path, and can't contain "." or ".." elements. Each slash separated
-# element of pattern can contain the following special characters:
-# - '?', which match any character
-# - '*', which matches arbitrary number of characters.
-# A file $(d)/e1/e2/e3 (where 'd' is in $(dirs)) matches pattern p1/p2/p3
-# if and only if e1 matches p1, e2 matches p2 and so on.
-#
-# For example:
-# [ glob . : *.cpp ]
-# [ glob . : */build/Jamfile ]
+# Returns the list of files matching the given pattern in the specified
+# directory. Both directories and patterns are supplied as portable paths. Each
+# pattern should be non-absolute path, and can't contain "." or ".." elements.
+# Each slash separated element of pattern can contain the following special
+# characters:
+# - '?', which match any character
+# - '*', which matches arbitrary number of characters.
+# A file $(d)/e1/e2/e3 (where 'd' is in $(dirs)) matches pattern p1/p2/p3 if and
+# only if e1 matches p1, e2 matches p2 and so on.
+#
+# For example:
+# [ glob . : *.cpp ]
+# [ glob . : */build/Jamfile ]
+#
rule glob ( dirs * : patterns + : exclude-patterns * )
{
local result ;
@@ -262,12 +263,11 @@
}
-# Recursive version of GLOB. Builds the glob of files while
-# also searching in the subdirectories of the given roots. An
-# optional set of exclusion patterns will filter out the
-# matching entries from the result. The exclusions also apply
-# to the subdirectory scanning, such that directories that
-# match the exclusion patterns will not be searched.
+# Recursive version of GLOB. Builds the glob of files while also searching in
+# the subdirectories of the given roots. An optional set of exclusion patterns
+# will filter out the matching entries from the result. The exclusions also
+# apply to the subdirectory scanning, such that directories that match the
+# exclusion patterns will not be searched.
#
rule glob-tree ( roots * : patterns + : exclude-patterns * )
{
@@ -311,9 +311,9 @@
NATIVE_RULE path : exists ;
-# Find out the absolute name of path and returns the list of all the parents,
-# starting with the immediate one. Parents are returned as relative names.
-# If 'upper_limit' is specified, directories above it will be pruned.
+# Find out the absolute name of path and returns the list of all the parents,
+# starting with the immediate one. Parents are returned as relative names. If
+# 'upper_limit' is specified, directories above it will be pruned.
#
rule all-parents ( path : upper_limit ? : cwd ? )
{
@@ -349,8 +349,8 @@
}
-# Search for 'pattern' in parent directories of 'dir', up till and including
-# 'upper_limit', if it is specified, or till the filesystem root otherwise.
+# Search for 'pattern' in parent directories of 'dir', up till and including
+# 'upper_limit', if it is specified, or till the filesystem root otherwise.
#
rule glob-in-parents ( dir : patterns + : upper-limit ? )
{
@@ -366,8 +366,8 @@
}
-# Assuming 'child' is a subdirectory of 'parent', return the relative
-# path from 'parent' to 'child'
+# Assuming 'child' is a subdirectory of 'parent', return the relative path from
+# 'parent' to 'child'.
#
rule relative ( child parent )
{
@@ -429,8 +429,9 @@
}
-# Returns the list of paths which are used by the operating system
-# for looking up programs
+# Returns the list of paths which are used by the operating system for looking
+# up programs.
+#
rule programs-path ( )
{
local result ;
@@ -451,10 +452,10 @@
local tokens = [ regex.split $(native) "[/\\]" ] ;
local result ;
- # Handle paths ending with slashes
+ # Handle paths ending with slashes.
if $(tokens[-1]) = ""
{
- tokens = $(tokens[1--2]) ; # discard the empty element
+ tokens = $(tokens[1--2]) ; # Discard the empty element.
}
result = [ path.join $(tokens) ] ;
@@ -518,16 +519,17 @@
rule native-CYGWIN ( path )
{
local result = $(path) ;
- if [ regex.match "(^/.:)" : $(path) ] # win absolute
+ if [ regex.match "(^/.:)" : $(path) ] # Windows absolute path.
{
- result = [ MATCH "^/?(.*)" : $(path) ] ; # remove leading '/'
+ result = [ MATCH "^/?(.*)" : $(path) ] ; # Remove leading '/'.
}
return [ native-UNIX $(result) ] ;
}
-# split-VMS: splits input native path into
-# device dir file (each part is optional),
+# split-path-VMS: splits input native path into device dir file (each part is
+# optional).
+#
# example:
#
# dev:[dir]file.c => dev: [dir] file.c
@@ -545,12 +547,11 @@
# Converts a native VMS path into a portable path spec.
#
-# Does not handle current-device absolute paths such
-# as "[dir]File.c" as it is not clear how to represent
-# them in the portable path notation.
+# Does not handle current-device absolute paths such as "[dir]File.c" as it is
+# not clear how to represent them in the portable path notation.
#
-# Adds a trailing dot (".") to the file part if no extension
-# is present (helps when converting it back into native path).
+# Adds a trailing dot (".") to the file part if no extension is present (helps
+# when converting it back into native path).
#
rule make-VMS ( native )
{
@@ -621,8 +622,8 @@
# Converts a portable path spec into a native VMS path.
#
-# Relies on having at least one dot (".") included in the file
-# name to be able to differentiate it ftom the directory part.
+# Relies on having at least one dot (".") included in the file name to be able
+# to differentiate it from the directory part.
#
rule native-VMS ( path )
{
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk