Boost logo

Boost-Commit :

From: jurko.gospodnetic_at_[hidden]
Date: 2008-06-08 15:41:57


Author: jurko
Date: 2008-06-08 15:41:56 EDT (Sun, 08 Jun 2008)
New Revision: 46254
URL: http://svn.boost.org/trac/boost/changeset/46254

Log:
Minor stylistic Boost Build script changes.
Text files modified:
   trunk/tools/build/v2/build/feature.jam | 45 ++++++
   trunk/tools/build/v2/build/project.jam | 88 ++++++++-----
   trunk/tools/build/v2/build/property-set.jam | 42 ++++--
   trunk/tools/build/v2/build/targets.jam | 112 ++++++++++--------
   trunk/tools/build/v2/kernel/class.jam | 72 +++++------
   trunk/tools/build/v2/kernel/errors.jam | 4
   trunk/tools/build/v2/kernel/modules.jam | 4
   trunk/tools/build/v2/tools/stage.jam | 9
   trunk/tools/build/v2/util/assert.jam | 243 ++++++++++++++++++++++++++++-----------
   trunk/tools/build/v2/util/container.jam | 13 +
   trunk/tools/build/v2/util/indirect.jam | 5
   trunk/tools/build/v2/util/path.jam | 24 +-
   12 files changed, 420 insertions(+), 241 deletions(-)

Modified: trunk/tools/build/v2/build/feature.jam
==============================================================================
--- trunk/tools/build/v2/build/feature.jam (original)
+++ trunk/tools/build/v2/build/feature.jam 2008-06-08 15:41:56 EDT (Sun, 08 Jun 2008)
@@ -42,6 +42,7 @@
 
 # Prepare a fresh space to test in by moving all global variable settings into
 # the given temporary module and erasing them here.
+#
 rule prepare-test ( temp-module )
 {
     DELETE_MODULE $(temp-module) ;
@@ -61,6 +62,7 @@
 
 # Clear out all global variables and recover all variables from the given
 # temporary module.
+#
 rule finish-test ( temp-module )
 {
     # Clear globals.
@@ -80,8 +82,9 @@
 }
 
 
-# Transform features by bracketing any elements which aren't already bracketed
+# Transform features by bracketing any elements which are not already bracketed
 # by "<>".
+#
 local rule grist ( features * )
 {
     local empty = "" ;
@@ -90,6 +93,7 @@
 
 
 # Declare a new feature with the given name, values, and attributes.
+#
 rule feature (
       name # Feature name.
     : values * # Allowable values - may be extended later using feature.extend.
@@ -118,15 +122,15 @@
     {
         error = free features cannot be propagated ;
     }
- else
+ else
     {
         local m = [ MATCH (.*=.*) : $(values) ] ;
         if $(m[1])
         {
             error = "feature value may not contain '='" ;
- }
+ }
     }
-
+
     if $(error)
     {
         errors.error $(error)
@@ -153,6 +157,7 @@
 
 
 # Sets the default value of the given feature, overriding any previous default.
+#
 rule set-default ( feature : value )
 {
     local f = [ grist $(feature) ] ;
@@ -166,6 +171,7 @@
 
 
 # Returns the default property values for the given features.
+#
 rule defaults ( features * )
 {
     local result ;
@@ -186,6 +192,7 @@
 
 
 # Returns true iff all 'names' elements are valid features.
+#
 rule valid ( names + )
 {
     if $(names) in $(.all-features)
@@ -196,6 +203,7 @@
 
 
 # Returns the attibutes of the given feature.
+#
 rule attributes ( feature )
 {
     return $($(:E=:G=$(feature)).attributes) ;
@@ -203,6 +211,7 @@
 
 
 # Returns the values of the given feature.
+#
 rule values ( feature )
 {
     return $($(:E=:G=$(feature)).values) ;
@@ -210,6 +219,7 @@
 
 
 # Returns true iff 'value-string' is a value-string of an implicit feature.
+#
 rule is-implicit-value ( value-string )
 {
     local v = [ regex.split $(value-string) - ] ;
@@ -238,6 +248,7 @@
 
 
 # Returns the implicit feature associated with the given implicit value.
+#
 rule implied-feature ( implicit-value )
 {
     local components = [ regex.split $(implicit-value) "-" ] ;
@@ -267,6 +278,7 @@
 # Given a feature and a value of one of its subfeatures, find the name of the
 # subfeature. If value-string is supplied, looks for implied subfeatures that
 # are specific to that value of feature
+#
 rule implied-subfeature (
       feature # The main feature name.
       subvalue # The value of one of its subfeatures.
@@ -286,6 +298,7 @@
 
 
 # Generate an error if the feature is unknown.
+#
 local rule validate-feature ( feature )
 {
     if ! $(feature) in $(.all-features)
@@ -305,6 +318,7 @@
 # return:
 #
 # <toolset>gcc <toolset-version>2.95.2 <toolset-os>linux <toolset-cpu>x86
+#
 local rule expand-subfeatures-aux (
       feature ? # Feature name or empty if value corresponds to an
                        # implicit property.
@@ -399,6 +413,7 @@
 
 
 # Helper for extend, below. Handles the feature case.
+#
 local rule extend-feature ( feature : values * )
 {
     feature = [ grist $(feature) ] ;
@@ -427,6 +442,7 @@
 
 
 # Checks that value-string is a valid value-string for the given feature.
+#
 rule validate-value-string ( feature value-string )
 {
     if ! (
@@ -464,6 +480,7 @@
 # between subvalue(s) and a subfeature
 # * value of that variable when such a subfeature/subvalue has been defined and
 # returns a list consisting of the latter followed by the former.
+#
 local rule subvalue-var (
     feature # Main feature name.
     value-string ? # If supplied, specifies a specific value of the main
@@ -518,6 +535,7 @@
 # Returns true iff the subvalues are valid for the feature. When the optional
 # value-string is provided, returns true iff the subvalues are valid for the
 # given value of the feature.
+#
 rule is-subvalue ( feature : value-string ? : subfeature : subvalue )
 {
     local subfeature-vars = [ subvalue-var $(feature) $(value-string)
@@ -591,6 +609,7 @@
 
 
 # Declares a subfeature.
+#
 rule subfeature (
     feature # Root feature that is not a subfeature.
     value-string ? # A value-string specifying which feature or subfeature
@@ -623,6 +642,7 @@
 
 
 # Set components of the given composite property.
+#
 rule compose ( composite-property : component-properties * )
 {
     local feature = $(composite-property:G) ;
@@ -654,6 +674,7 @@
 
 
 # Return all values of the given feature specified by the given property set.
+#
 rule get-values ( feature : properties * )
 {
     local result ;
@@ -681,6 +702,7 @@
 
 # Expand all composite properties in the set so that all components are
 # explicitly expressed.
+#
 rule expand-composites ( properties * )
 {
     local explicit-features = $(properties:G) ;
@@ -739,6 +761,7 @@
 # Return true iff f is an ordinary subfeature of the parent-property's feature,
 # or if f is a subfeature of the parent-property's feature specific to the
 # parent-property's value.
+#
 local rule is-subfeature-of ( parent-property f )
 {
     if subfeature in $($(f).attributes)
@@ -769,6 +792,7 @@
 
 
 # As for is-subfeature-of but for subproperties.
+#
 local rule is-subproperty-of ( parent-property p )
 {
     return [ is-subfeature-of $(parent-property) $(p:G) ] ;
@@ -778,6 +802,7 @@
 # Given a property, return the subset of features consisting of all ordinary
 # subfeatures of the property's feature, and all specific subfeatures of the
 # property's feature which are conditional on the property's value.
+#
 local rule select-subfeatures ( parent-property : features * )
 {
     return [ sequence.filter is-subfeature-of $(parent-property) : $(features) ] ;
@@ -785,6 +810,7 @@
 
 
 # As for select-subfeatures but for subproperties.
+#
 local rule select-subproperties ( parent-property : properties * )
 {
     return [ sequence.filter is-subproperty-of $(parent-property) : $(properties) ] ;
@@ -799,6 +825,7 @@
 # of those features due to composite feature expansion to be dropped. If two
 # values of a given non-free feature are directly expressed in the input, an
 # error is issued.
+#
 rule expand ( properties * )
 {
     local expanded = [ expand-subfeatures $(properties) ] ;
@@ -808,6 +835,7 @@
 
 # Helper rule for minimize. Returns true iff property's feature is present in
 # the contents of the variable named by feature-set-var.
+#
 local rule in-features ( feature-set-var property )
 {
     if $(property:G) in $($(feature-set-var))
@@ -819,6 +847,7 @@
 
 # Helper rule for minimize. Returns the list with the same properties, but with
 # all subfeatures moved to the end of the list.
+#
 local rule move-subfeatures-to-the-end ( properties * )
 {
     local x1 ;
@@ -844,6 +873,7 @@
 # they override a value from some composite property. Implicit properties will
 # be expressed without feature grist, and sub-property values will be expressed
 # as elements joined to the corresponding main property.
+#
 rule minimize ( properties * )
 {
     # Precondition checking
@@ -913,8 +943,9 @@
 # Requires: for every subproperty, there is a parent property. All features are
 # explicitly expressed.
 #
-# This rule probably shouldn't be needed, but build-request.expand-no-defaults
+# This rule probably should not be needed, but build-request.expand-no-defaults
 # is being abused for unintended purposes and it needs help.
+#
 rule compress-subproperties ( properties * )
 {
     local all-subs ;
@@ -954,6 +985,7 @@
 # feature name followed by a dash, and return a pair consisting of the parts
 # before and after that dash. More interesting than a simple split because
 # feature names may contain dashes.
+#
 local rule split-top-feature ( feature-plus )
 {
     local e = [ regex.split $(feature-plus) - ] ;
@@ -989,6 +1021,7 @@
 # <variant>debug <runtime_debugging>off
 #
 # and that's kind of strange.
+#
 rule add-defaults ( properties * )
 {
     for local v in $(properties:G=)
@@ -1033,6 +1066,7 @@
 # Note that vN...vM may contain slashes. This needs to be resilient to the
 # substitution of backslashes for slashes, since Jam, unbidden, sometimes swaps
 # slash direction on NT.
+#
 rule split ( property-set )
 {
     local pieces = [ regex.split $(property-set) [\\/] ] ;
@@ -1055,6 +1089,7 @@
 
 
 # Tests of module feature.
+#
 local rule __test__ ( )
 {
     # Use a fresh copy of the feature module.

Modified: trunk/tools/build/v2/build/project.jam
==============================================================================
--- trunk/tools/build/v2/build/project.jam (original)
+++ trunk/tools/build/v2/build/project.jam 2008-06-08 15:41:56 EDT (Sun, 08 Jun 2008)
@@ -4,36 +4,35 @@
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
 
-# Implements project representation and loading. Each project is represented
-# by:
-# - a module where all the Jamfile content live.
-# - an instance of 'project-attributes' class.
-# (given a module name, can be obtained using the 'attributes' rule)
-# - an instance of 'project-target' class (from targets.jam)
-# (given a module name, can be obtained using the 'target' rule)
-#
-# Typically, projects are created as result of loading a Jamfile, which is done
-# by rules 'load' and 'initialize', below. First, module for Jamfile is loaded
-# and new project-attributes instance is created. Some rules necessary for
-# project are added to the module (see 'project-rules' module) at the bottom of
-# this file. Default project attributes are set (inheriting attributes of
-# parent project, if it exists). After that the Jamfile is read. It can declare
-# its own attributes using the 'project' rule which will be combined with any
-# alread set attributes.
-#
-# The 'project' rule can also declare a project id which will be associated
-# with the project module.
-#
-# There can also be 'standalone' projects. They are created by calling
-# 'initialize' on an arbitrary module and not specifying their location. After
-# the call, the module can call the 'project' rule, declare main targets and
-# behave as a regular project except that, since it's not associated with any
-# location, it should not declare targets that are not prebuilt.
-#
-# The list of all loaded Jamfile is stored in the .project-locations variable.
-# It's possible to obtain a module name for a location using the 'module-name'
-# rule. Standalone projects are not recorded and can only be referenced using
-# their project id.
+# Implements project representation and loading. Each project is represented by:
+# - a module where all the Jamfile content live.
+# - an instance of 'project-attributes' class.
+# (given a module name, can be obtained using the 'attributes' rule)
+# - an instance of 'project-target' class (from targets.jam)
+# (given a module name, can be obtained using the 'target' rule)
+#
+# Typically, projects are created as result of loading a Jamfile, which is done
+# by rules 'load' and 'initialize', below. First, module for Jamfile is loaded
+# and new project-attributes instance is created. Some rules necessary for
+# project are added to the module (see 'project-rules' module) at the bottom of
+# this file. Default project attributes are set (inheriting attributes of parent
+# project, if it exists). After that the Jamfile is read. It can declare its own
+# attributes using the 'project' rule which will be combined with any already
+# set attributes.
+#
+# The 'project' rule can also declare a project id which will be associated with
+# the project module.
+#
+# There can also be 'standalone' projects. They are created by calling
+# 'initialize' on an arbitrary module and not specifying their location. After
+# the call, the module can call the 'project' rule, declare main targets and
+# behave as a regular project except that, since it is not associated with any
+# location, it should not declare targets that are not prebuilt.
+#
+# The list of all loaded Jamfile is stored in the .project-locations variable.
+# It is possible to obtain a module name for a location using the 'module-name'
+# rule. Standalone projects are not recorded and can only be referenced using
+# their project id.
 
 import "class" : new ;
 import errors ;
@@ -94,13 +93,14 @@
 
 
 # Note the use of character groups, as opposed to listing 'Jamroot' and
-# 'jamroot'. With the latter, we'd get duplicate matches on Windows and would
-# have to eliminate duplicates.
+# 'jamroot'. With the latter, we would get duplicate matches on Windows and
+# would have to eliminate duplicates.
 JAMROOT ?= [ modules.peek : JAMROOT ] ;
 JAMROOT ?= project-root.jam [Jj]amroot [Jj]amroot.jam ;
 
 
 # Loads parent of Jamfile at 'location'. Issues an error if nothing is found.
+#
 rule load-parent ( location )
 {
     local found = [ path.glob-in-parents $(location) :
@@ -120,6 +120,7 @@
 # Makes the specified 'module' act as if it were a regularly loaded Jamfile at
 # 'location'. Reports an error if a Jamfile has already been loaded for that
 # location.
+#
 rule act-as-jamfile ( module : location )
 {
     if [ module-name $(location) ] in $(.jamfile-modules)
@@ -139,6 +140,7 @@
 
 # Returns the project module corresponding to the given project-id or plain
 # directory name. Returns nothing if such a project can not be found.
+#
 rule find ( name : current-location )
 {
     local project-module ;
@@ -489,6 +491,7 @@
 
 
 # Make 'project-module' inherit attributes of project root and parent module.
+#
 rule inherit-attributes ( project-module : parent-module )
 {
     local attributes = $($(project-module).attributes) ;
@@ -528,6 +531,7 @@
 
 
 # Associate the given id with the given project module.
+#
 rule register-id ( id : module )
 {
     $(id).jamfile-module = $(module) ;
@@ -538,6 +542,7 @@
 #
 # The standard attributes are "id", "location", "project-root", "parent"
 # "requirements", "default-build", "source-location" and "projects-to-build".
+#
 class project-attributes
 {
     import property ;
@@ -556,6 +561,7 @@
 
     # Set the named attribute from the specification given by the user. The
     # value actually set may be different.
+ #
     rule set ( attribute : specification *
         : exact ? # Sets value from 'specification' without any processing.
         )
@@ -640,12 +646,14 @@
     }
 
     # Returns the value of the given attribute.
+ #
     rule get ( attribute )
     {
         return $(self.$(attribute)) ;
     }
 
     # Prints the project attributes.
+ #
     rule print ( )
     {
         local id = $(self.id) ; id ?= (none) ;
@@ -664,6 +672,7 @@
 
 
 # Returns the project which is currently being loaded.
+#
 rule current ( )
 {
     return $(.current-project) ;
@@ -672,6 +681,7 @@
 
 # Temporarily changes the current project to 'project'. Should be followed by
 # 'pop-current'.
+#
 rule push-current ( project )
 {
     .saved-current-project += $(.current-project) ;
@@ -687,6 +697,7 @@
 
 
 # Returns the project-attribute instance for the specified Jamfile module.
+#
 rule attributes ( project )
 {
     return $($(project).attributes) ;
@@ -694,6 +705,7 @@
 
 
 # Returns the value of the specified attribute in the specified Jamfile module.
+#
 rule attribute ( project attribute )
 {
     return [ $($(project).attributes).get $(attribute) ] ;
@@ -701,6 +713,7 @@
 
 
 # Returns the project target corresponding to the 'project-module'.
+#
 rule target ( project-module )
 {
     if ! $(.target.$(project-module))
@@ -714,6 +727,7 @@
 
 
 # Use/load a project.
+#
 rule use ( id : location )
 {
     local saved-project = $(.current-project) ;
@@ -810,6 +824,7 @@
 
 
 # This module defines rules common to all projects.
+#
 module project-rules
 {
     rule using ( toolset-module : * )
@@ -926,8 +941,8 @@
     # child Jamfile.
     #
     rule constant (
- name # Variable name of the constant.
- : value + # Value of the constant.
+ name # Variable name of the constant.
+ : value + # Value of the constant.
         )
     {
         import project ;
@@ -938,6 +953,7 @@
     # Declare and set a project global constant, whose value is a path. The path
     # is adjusted to be relative to the invocation directory. The given value
     # path is taken to be either absolute, or relative to this project root.
+ #
     rule path-constant (
         name # Variable name of the constant.
         : value + # Value of the constant.
@@ -979,8 +995,8 @@
     rule glob ( wildcards + : excludes * )
     {
         import project ;
- return [ project.glob-internal [ project.current ]
- : $(wildcards) : $(excludes) : glob ] ;
+ return [ project.glob-internal [ project.current ] : $(wildcards) :
+ $(excludes) : glob ] ;
     }
 
     rule glob-tree ( wildcards + : excludes * )

Modified: trunk/tools/build/v2/build/property-set.jam
==============================================================================
--- trunk/tools/build/v2/build/property-set.jam (original)
+++ trunk/tools/build/v2/build/property-set.jam 2008-06-08 15:41:56 EDT (Sun, 08 Jun 2008)
@@ -9,22 +9,23 @@
 import sequence ;
 import set ;
 
+
 # Class for storing a set of properties.
-# - there's 1<->1 correspondence between identity and value. No two instances of
-# the class are equal. To maintain this property, the 'property-set.create'
-# rule should be used to create new instances. Instances are immutable.
 #
-# - each property is classified with regard to it's effect on build results.
-# Incidental properties have no effect on build results, from Boost.Build's
-# point of view. Others are either free, or non-free, which we call 'base'.
-# Each property belongs to exactly one of those categories and it's possible
-# to get list of properties in each category.
+# There is 1<->1 correspondence between identity and value. No two instances
+# of the class are equal. To maintain this property, the 'property-set.create'
+# rule should be used to create new instances. Instances are immutable.
+#
+# Each property is classified with regard to its effect on build results.
+# Incidental properties have no effect on build results, from Boost.Build's
+# point of view. Others are either free, or non-free and we refer to non-free
+# ones as 'base'. Each property belongs to exactly one of those categories.
 #
-# In addition, it's possible to get a list of properties with a specific
-# attribute.
+# It is possible to get a list of properties belonging to each category as
+# well as a list of properties with a specific attribute.
 #
-# - several operations, like and refine and as-path are provided. They all use
-# caching whenever possible.
+# Several operations, like and refine and as-path are provided. They all use
+# caching whenever possible.
 #
 class property-set
 {
@@ -92,6 +93,7 @@
     }
 
     # Returns Jam list of stored properties.
+ #
     rule raw ( )
     {
         return $(self.raw) ;
@@ -103,18 +105,21 @@
     }
 
     # Returns properties that are neither incidental nor free.
+ #
     rule base ( )
     {
         return $(self.base) ;
     }
 
- # Returns free properties which are not dependency properties.
+ # Returns free properties which are not incidental.
+ #
     rule free ( )
     {
         return $(self.free) ;
     }
 
     # Returns dependency properties.
+ #
     rule dependency ( )
     {
         return $(self.dependency) ;
@@ -136,6 +141,7 @@
     }
 
     # Returns incidental properties.
+ #
     rule incidental ( )
     {
         return $(self.incidental) ;
@@ -239,6 +245,7 @@
     # Returns a list of
     # - the computed path
     # - if the path is relative to the build directory, a value of 'true'.
+ #
     rule target-path ( )
     {
         if ! $(self.target-path)
@@ -318,6 +325,7 @@
     }
 
     # Returns all values of 'feature'.
+ #
     rule get ( feature )
     {
         if ! $(self.map-built)
@@ -338,6 +346,7 @@
 
 # Creates a new 'property-set' instance for the given raw properties or returns
 # an already existing ones.
+#
 rule create ( raw-properties * )
 {
     raw-properties = [ sequence.unique
@@ -356,6 +365,7 @@
 
 # Creates a new 'property-set' instance after checking that all properties are
 # valid and converting incidental properties into gristed form.
+#
 rule create-with-validation ( raw-properties * )
 {
     property.validate $(raw-properties) ;
@@ -365,6 +375,7 @@
 
 # Creates a property-set from the input given by the user, in the context of
 # 'jamfile-module' at 'location'.
+#
 rule create-from-user-input ( raw-properties * : jamfile-module location )
 {
     local specification = [ property.translate-paths $(raw-properties)
@@ -386,8 +397,8 @@
 # bound.
 # - location -- path to which path features are relative.
 #
-rule refine-from-user-input ( parent-requirements : specification *
- : project-module : location )
+rule refine-from-user-input ( parent-requirements : specification * :
+ project-module : location )
 {
     if ! $(specification)
     {
@@ -434,6 +445,7 @@
 
 
 # Returns a property-set with an empty set of properties.
+#
 rule empty ( )
 {
     if ! $(.empty)

Modified: trunk/tools/build/v2/build/targets.jam
==============================================================================
--- trunk/tools/build/v2/build/targets.jam (original)
+++ trunk/tools/build/v2/build/targets.jam 2008-06-08 15:41:56 EDT (Sun, 08 Jun 2008)
@@ -507,7 +507,7 @@
         # Import rules from parent.
         local this-module = [ project-module ] ;
         local parent-module = [ $(parent).project-module ] ;
- # Don't import rules coming from 'project-rules' as they must be
+ # Do not import rules coming from 'project-rules' as they must be
         # imported localized.
         local user-rules = [ set.difference
             [ RULENAMES $(parent-module) ] :
@@ -832,7 +832,7 @@
 #
 rule resolve-reference ( target-reference : project )
 {
- # Separate target name from properties override
+ # Separate target name from properties override.
     local split = [ MATCH "^([^<]*)(/(<.*))?$" : $(target-reference) ] ;
     local id = $(split[1]) ;
     local sproperties = ;
@@ -842,7 +842,7 @@
         sproperties = [ feature.expand-composites $(sproperties) ] ;
     }
 
- # Find the target
+ # Find the target.
     local target = [ $(project).find $(id) ] ;
 
     return $(target) [ property-set.create $(sproperties) ] ;
@@ -880,16 +880,23 @@
 
 
 # Given a build request and requirements, return properties common to dependency
-# build request and target build properties.
+# build request and target requirements.
+#
+# TODO: Document exactly what 'common properties' are, whether they should
+# include default property values, whether they should contain any conditional
+# properties or should those be already processed, etc. See whether there are
+# any differences between use cases with empty and non-empty build-request as
+# well as with requirements containing and those not containing any non-free
+# features.
 #
 rule common-properties ( build-request requirements )
 {
     # For optimization, we add free requirements directly, without using a
- # complex algorithm. This gives the complex algorithm better chance of
+ # complex algorithm. This gives the complex algorithm a better chance of
     # caching results.
     local free = [ $(requirements).free ] ;
- local non-free = [ property-set.create
- [ $(requirements).base ] [ $(requirements).incidental ] ] ;
+ local non-free = [ property-set.create [ $(requirements).base ]
+ [ $(requirements).incidental ] ] ;
 
     local key = .rp.$(build-request)-$(non-free) ;
     if ! $($(key))
@@ -900,7 +907,7 @@
 }
 
 
-# Given 'context' -- a set of already present properties, and 'requirements',
+# Given a 'context' -- a set of already present properties, and 'requirements',
 # decide which extra properties should be applied to 'context'. For conditional
 # requirements, this means evaluating condition. For indirect conditional
 # requirements, this means calling a rule. Ordinary requirements are always
@@ -915,13 +922,13 @@
 #
 rule evaluate-requirements ( requirements : context : what )
 {
- # Apply non-conditional requirements. It's possible that further conditional
- # requirement change a value set by non-conditional requirements. For
- # example:
+ # Apply non-conditional requirements. It is possible that further
+ # conditional requirement change a value set by non-conditional
+ # requirements. For example:
     #
     # exe a : a.cpp : <threading>single <toolset>foo:<threading>multi ;
     #
- # I'm not sure if this should be an error, or not, especially given that
+ # I am not sure if this should be an error, or not, especially given that
     #
     # <threading>single
     #
@@ -932,15 +939,15 @@
     local raw = [ $(context).raw ] ;
     raw = [ property.refine $(raw) : $(unconditional) ] ;
 
- # We've collected properties that surely must be present in common
+ # We have collected properties that surely must be present in common
     # properties. We now try to figure out what other properties should be added
     # in order to satisfy rules (4)-(6) from the docs.
 
     local conditionals = [ $(requirements).conditional ] ;
     # The 'count' variable has one element for each conditional feature and for
- # each occurence of '<indirect-conditional>' feature. It's used as a loop
+ # each occurence of '<indirect-conditional>' feature. It is used as a loop
     # counter: for each iteration of the loop before we remove one element and
- # the property set should stabilize before we're done. It's assumed that
+ # the property set should stabilize before we are done. It is assumed that
     # #conditionals iterations should be enough for properties to propagate
     # along conditions in any direction.
     local count = $(conditionals)
@@ -951,9 +958,9 @@
 
     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 <indirect-conditional>
+ # It is assumed that ordinary conditional requirements can not add
+ # <indirect-conditional> properties, and that rules referred to by
+ # <indirect-conditional> properties can not add new <indirect-conditional>
     # properties. So the list of indirect conditionals does not change.
     local indirect = [ $(requirements).get <conditional> ] ;
     indirect = [ MATCH @(.*) : $(indirect) ] ;
@@ -979,9 +986,9 @@
         }
         else
         {
- # Oops, results of evaluation of conditionals has changed. Also
- # 'current' contains leftover from previous evaluation. Recompute
- # 'current' using initial properties and conditional requirements.
+ # Oops, conditional evaluation results have changed. Also 'current'
+ # contains leftovers from a previous evaluation. Recompute 'current'
+ # using initial properties and conditional requirements.
             added-requirements = $(e) ;
             current = [ property.refine $(raw) : [ feature.expand $(e) ] ] ;
         }
@@ -989,7 +996,7 @@
     }
     if ! $(ok)
     {
- errors.error "Can't evaluate conditional properties " $(conditionals) ;
+ errors.error "Can not evaluate conditional properties " $(conditionals) ;
     }
 
     if $(what) = added
@@ -1011,18 +1018,18 @@
 {
     # This guarantees that default properties are present in the result, unless
     # they are overriden 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
+ # we have added <foo>bar, which is composite and expands to <foo2>bar2, but
+ # default value of <foo2> is not bar2, in which case it is not clear what to
     # do.
     #
     build-request = [ $(build-request).add-defaults ] ;
     # Features added by 'add-default' can be composite and expand to features
     # without default values -- so they are not added yet. It could be clearer/
- # /faster to expand only newly added properties but that's not critical.
+ # /faster to expand only newly added properties but that is not critical.
     build-request = [ $(build-request).expand ] ;
 
- return [ evaluate-requirements $(requirements)
- : $(build-request) : refined ] ;
+ return [ evaluate-requirements $(requirements) : $(build-request) :
+ refined ] ;
 }
 
 
@@ -1177,7 +1184,7 @@
 
         if ! $(self.generated.$(property-set))
         {
- # Apply free features form the command line. If user said
+ # Apply free features from the command line. If user said
             # define=FOO
             # he most likely wants this define to be set for all compiles.
             property-set = [ $(property-set).refine
@@ -1188,7 +1195,7 @@
             if [ modules.peek : .debug-building ]
             {
                 ECHO ;
- ECHO [ targets.indent ] "Common properties:" [ $(rproperties).raw ] ;
+ ECHO [ targets.indent ] "Common properties: " [ $(rproperties).raw ] ;
             }
 
             if $(rproperties[1]) != "@error" && [ $(rproperties).get <build> ] != no
@@ -1206,8 +1213,8 @@
                 if [ modules.peek : .debug-building ]
                 {
                     ECHO ;
- ECHO [ targets.indent ]
- "Usage requirements for $(self.name) are " $(usage-requirements) ;
+ ECHO [ targets.indent ] "Usage requirements for"
+ $(self.name)": " $(usage-requirements) ;
                 }
 
                 rproperties = [ property-set.create $(properties)
@@ -1216,8 +1223,8 @@
 
                 if [ modules.peek : .debug-building ]
                 {
- ECHO [ targets.indent ]
- "Build properties: " [ $(rproperties).raw ] ;
+ ECHO [ targets.indent ] "Build properties: "
+ [ $(rproperties).raw ] ;
                 }
 
                 local extra = [ $(rproperties).get <source> ] ;
@@ -1245,9 +1252,8 @@
                     $(s).set-usage-requirements $(ur) ;
                     if [ modules.peek : .debug-building ]
                     {
- ECHO [ targets.indent ]
- "Usage requirements from $(self.name) are"
- [ $(ur).raw ] ;
+ ECHO [ targets.indent ] "Usage requirements from"
+ $(self.name)": " [ $(ur).raw ] ;
                     }
 
                     self.generated.$(property-set) = $(ur) $(result) ;
@@ -1262,27 +1268,28 @@
                 }
                 else if [ $(rproperties).get <build> ] = no
                 {
- ECHO [ targets.indent ]
- "Skipping build of: " [ full-name ] " <build>no in common properties" ;
+ ECHO [ targets.indent ] "Skipping build of: " [ full-name ]
+ " <build>no in common properties" ;
                 }
                 else
                 {
- ECHO [ targets.indent ] "Skipping build of: " [ full-name ] " unknown reason" ;
+ ECHO [ targets.indent ] "Skipping build of: " [ full-name ]
+ " unknown reason" ;
                 }
 
- # We are 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
-
- # If this target fails to build, add <build>no to properties
- # to cause any parent target to fail to build. Except that it
+ # We are here either because there has been an error computing
+ # properties or there is <build>no in properties. In the latter
+ # case we do not want any diagnostic. In the former case, we
+ # need diagnostics. FIXME
+
+ # If this target fails to build, add <build>no to properties to
+ # cause any parent target to fail to build. Except that it
                 # - does not work now, since we check for <build>no only in
                 # common properties, but not in properties that came from
                 # dependencies
- # - it's not clear if that's a good idea anyway. The alias
- # target, for example, should not fail to build if a dependency
- # fails.
+ # - it is not clear if that is a good idea anyway. The alias
+ # target, for example, should not fail to build if a
+ # dependency fails.
                 self.generated.$(property-set) = [ property-set.create <build>no ] ;
             }
         }
@@ -1293,7 +1300,10 @@
                 ECHO [ targets.indent ] "Already built" ;
                 local ur = $(self.generated.$(property-set)) ;
                 ur = $(ur[0]) ;
- ECHO [ targets.indent ] " Usage requirements " [ $(ur).raw ] ;
+ targets.increase-indent ;
+ ECHO [ targets.indent ] "Usage requirements from"
+ $(self.name)": " [ $(ur).raw ] ;
+ targets.decrease-indent ;
             }
         }
 
@@ -1319,7 +1329,7 @@
         local result = [ property-set.create
             [ $(xusage-requirements).non-dependency ] $(extra) ] ;
 
- # Propagate usage requirements we've got from sources, except for the
+ # Propagate usage requirements we got from sources, except for the
         # <pch-header> and <pch-file> features.
         #
         # That feature specifies which pch file to use, and should apply only to

Modified: trunk/tools/build/v2/kernel/class.jam
==============================================================================
--- trunk/tools/build/v2/kernel/class.jam (original)
+++ trunk/tools/build/v2/kernel/class.jam 2008-06-08 15:41:56 EDT (Sun, 08 Jun 2008)
@@ -62,13 +62,8 @@
 # base-name.method-name. By convention, attribute names are prefixed with
 # "self.".
 
-import numbers ;
-import errors : * ;
-import set ;
 import modules ;
-import assert ;
-
-classes = ;
+import numbers ;
 
 
 rule xinit ( instance : class )
@@ -89,10 +84,10 @@
     xinit $(id) : $(class) ;
 
     INSTANCE $(id) : class@$(class) ;
- IMPORT_MODULE $(id) : ;
+ IMPORT_MODULE $(id) ;
     $(id).__init__ $(args) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ;
 
- # bump the next unique object name
+ # Bump the next unique object name.
     .next-instance = [ numbers.increment $(.next-instance) ] ;
 
     # Return the name of the new instance.
@@ -102,11 +97,6 @@
 
 rule bases ( class )
 {
- #if ! ( $(class) in $(classes) )
- #{
- # error class $(class) not defined ;
- #}
-
     module class@$(class)
     {
         return $(__bases__) ;
@@ -116,15 +106,9 @@
 
 rule is-derived ( class : bases + )
 {
- #local all = $(class) $(bases) ;
- #if ! ( $(all) in $(classes) )
- #{
- # error class(es) [ set.difference $(class) $(bases) : $(classes) ] not defined ;
- #}
-
     local stack = $(class) ;
     local visited found ;
- while ( ! $(found) ) && $(stack)
+ while ! $(found) && $(stack)
     {
         local top = $(stack[1]) ;
         stack = $(stack[2-]) ;
@@ -154,9 +138,9 @@
 # Check if the given value is of the given type.
 #
 rule is-a (
- instance # The value to check.
- : type # The type to test for.
- )
+ instance # The value to check.
+ : type # The type to test for.
+)
 {
     if [ is-instance $(instance) ]
     {
@@ -177,18 +161,18 @@
 
 local rule __test__ ( )
 {
- import "class" : * ;
     import assert ;
- import errors : * ;
+ import "class" : new ;
 
     # This will be the construction function for a class called 'myclass'.
+ #
     class myclass
     {
- import assert : nonempty-variable ;
+ import assert ;
 
         rule __init__ ( x_ * : y_ * )
         {
- # set some instance variables
+ # Set some instance variables.
             x = $(x_) ;
             y = $(y_) ;
             foo += 10 ;
@@ -265,7 +249,8 @@
             z = $(z_) ;
         }
 
- # override g
+ # Override g.
+ #
         rule g ( args * )
         {
             return derived1.g ;
@@ -282,16 +267,19 @@
         }
 
         # Check that 'assert.equal' visible in base class is visible here.
+ #
         rule invariant2 ( )
         {
             assert.equal 2 : 2 ;
         }
 
- # Check that 'nonempty-variable' visible in base class is visible here.
+ # Check that 'assert.variable-not-empty' visible in base class is
+ # visible here.
+ #
         rule invariant3 ( )
         {
             local v = 10 ;
- nonempty-variable v ;
+ assert.nonempty-variable v ;
         }
     }
 # class derived1 : myclass ;
@@ -303,17 +291,19 @@
             myclass.__init__ 1 : 2 ;
         }
 
- # override g
+ # Override g.
+ #
         rule g ( args * )
         {
             return derived2.g ;
         }
 
- rule get-x ( )
- {
- # Test the ability to call base class functions with qualification.
- return [ myclass.get-x ] ;
- }
+ # Test the ability to call base class functions with qualification.
+ #
+ rule get-x ( )
+ {
+ return [ myclass.get-x ] ;
+ }
     }
 # class derived2 : myclass ;
 
@@ -339,9 +329,9 @@
     expect_derived2 $(e) ;
 
     # Argument checking is set up to call exit(1) directly on failure, and we
- # can't hijack that with try, so we'd better not do this test by default.
- # We could fix this by having errors look up and invoke the EXIT rule
- # instead; EXIT can be hijacked (;-)
+ # can not hijack that with try, so we should better not do this test by
+ # default. We could fix this by having errors look up and invoke the EXIT
+ # rule instead; EXIT can be hijacked (;-)
     if --fail-typecheck in [ modules.peek : ARGV ]
     {
         try ;
@@ -349,8 +339,8 @@
             expect_derived2 $(a) ;
         }
         catch
- "Expected an instance of derived2 but got" instead
- ;
+ "Expected an instance of derived2 but got" instead
+ ;
     }
 
     #try ;

Modified: trunk/tools/build/v2/kernel/errors.jam
==============================================================================
--- trunk/tools/build/v2/kernel/errors.jam (original)
+++ trunk/tools/build/v2/kernel/errors.jam 2008-06-08 15:41:56 EDT (Sun, 08 Jun 2008)
@@ -102,7 +102,7 @@
 
                 .last-error-$(.args) = ;
                 error-skip-frames 3 expected \"$(v)\" in argument $(n) of error
- : got \"$(joined)\" instead ;
+ : got \"$(joined)\" instead ;
             }
         }
     }
@@ -164,6 +164,7 @@
 
 
 # Same as 'error', but the generated backtrace will include only user files.
+#
 rule user-error ( messages * : * )
 {
     .user-modules-only = 1 ;
@@ -172,6 +173,7 @@
 
 
 # Print a warning message with a stack backtrace and exit.
+#
 rule warning
 {
     backtrace 2 warning: $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ;

Modified: trunk/tools/build/v2/kernel/modules.jam
==============================================================================
--- trunk/tools/build/v2/kernel/modules.jam (original)
+++ trunk/tools/build/v2/kernel/modules.jam 2008-06-08 15:41:56 EDT (Sun, 08 Jun 2008)
@@ -94,7 +94,7 @@
 # Call the given rule locally in the given module. Use this for rules accepting
 # rule names as arguments, so that the passed rule may be invoked in the context
 # of the rule's caller (for example, if the rule accesses module globals or is a
-# local rule). Note that rules called this way may accept at most 8 parmeters.
+# local rule). Note that rules called this way may accept at most 8 parameters.
 #
 rule call-in ( module-name ? : rule-name args * : * )
 {
@@ -108,7 +108,7 @@
 # Given a possibly qualified rule name and arguments, remove any initial module
 # qualification from the rule and invoke it in that module. If there is no
 # module qualification, the rule is invoked in the global module. Note that
-# rules called this way may accept at most 8 parmeters.
+# rules called this way may accept at most 8 parameters.
 #
 rule call-locally ( qualified-rule-name args * : * )
 {

Modified: trunk/tools/build/v2/tools/stage.jam
==============================================================================
--- trunk/tools/build/v2/tools/stage.jam (original)
+++ trunk/tools/build/v2/tools/stage.jam 2008-06-08 15:41:56 EDT (Sun, 08 Jun 2008)
@@ -56,7 +56,6 @@
         if ! $(loc)
         {
             loc = [ path.root $(self.name) [ $(self.project).get location ] ] ;
-
             property-set = [ $(property-set).add-raw $(loc:G=<location>) ] ;
         }
 
@@ -76,7 +75,7 @@
             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.
+ # only if the user has explicitly requested it, nuke all
             # <dll-path> properties
             if [ $(property-set).get <hardcode-dll-paths> ] != true
             {
@@ -158,7 +157,7 @@
             {
                 if $(ename)
                 {
- errors.error "In 'install': <name> property specified with target that requires relinking" ;
+ errors.error "In 'install': <name> property specified with target that requires relinking." ;
                 }
                 else
                 {
@@ -200,7 +199,7 @@
             source-targets = [ collect-targets $(source-targets) ] ;
         }
 
- # Filter the target types, if needed
+ # Filter the target types, if needed.
         local included-types = [ $(property-set).get <install-type> ] ;
         for local r in $(source-targets)
         {
@@ -234,7 +233,7 @@
         return $(result) ;
     }
 
- # CONSIDER: figure out why we can't use virtual-target.traverse here.
+ # CONSIDER: figure out why we can not use virtual-target.traverse here.
     #
     rule collect-targets ( targets * )
     {

Modified: trunk/tools/build/v2/util/assert.jam
==============================================================================
--- trunk/tools/build/v2/util/assert.jam (original)
+++ trunk/tools/build/v2/util/assert.jam 2008-06-08 15:41:56 EDT (Sun, 08 Jun 2008)
@@ -1,119 +1,205 @@
-# Copyright 2001, 2002, 2003 Dave Abrahams
-# Copyright 2006 Rene Rivera
-# Copyright 2002, 2003 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 2001, 2002, 2003 Dave Abrahams
+# Copyright 2006 Rene Rivera
+# Copyright 2002, 2003 Vladimir Prus
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
 
-import errors : error-skip-frames lol->list ;
+import errors ;
 import modules ;
 
 
-# Assert the equality of A and B.
+################################################################################
+#
+# Private implementation details.
+#
+################################################################################
+
+# Rule added as a replacement for the regular Jam = operator but which does not
+# ignore trailing empty string elements.
+#
+local rule exact-equal-test ( lhs * : rhs * )
+{
+ local lhs_extended = $(lhs) xxx ;
+ local rhs_extended = $(rhs) xxx ;
+ if $(lhs_extended) = $(rhs_extended)
+ {
+ return true ;
+ }
+}
+
+
+# Two lists are considered set-equal if they contain the same elements, ignoring
+# duplicates and ordering.
+#
+local rule set-equal-test ( set1 * : set2 * )
+{
+ if ( $(set1) in $(set2) ) && ( $(set2) in $(set1) )
+ {
+ return true ;
+ }
+}
+
+
+################################################################################
+#
+# Public interface.
+#
+################################################################################
+
+# Assert the equality of A and B, ignoring trailing empty string elements.
 #
 rule equal ( a * : b * )
 {
     if $(a) != $(b)
     {
- error-skip-frames 3 assertion failure: \"$(a)\" "!=" \"$(b)\" ;
+ errors.error-skip-frames 3 assertion failure: \"$(a)\" "==" \"$(b)\"
+ (ignoring trailing empty strings) ;
     }
 }
 
 
-# Assert that EXPECTED is the result of calling RULE-NAME with the given
-# arguments.
+# Assert that the result of calling RULE-NAME on the given arguments has a false
+# logical value (is either an empty list or all empty strings).
 #
-rule result ( expected * : rule-name args * : * )
+rule false ( rule-name args * : * )
 {
     local result ;
     module [ CALLER_MODULE ]
     {
- modules.poke assert : result
- : [ $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ] ;
+ modules.poke assert : result : [ $(1) : $(2) : $(3) : $(4) : $(5) : $(6)
+ : $(7) : $(8) : $(9) ] ;
     }
 
- if $(result) != $(expected)
+ if $(result)
     {
- error-skip-frames 3 assertion failure: "[" $(rule-name)
- [ lol->list $(args) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ]
- "]"
- : expected: \"$(expected)\"
- : got: \"$(result)\" ;
+ errors.error-skip-frames 3 assertion failure: Expected false result from
+ "[" $(rule-name) [ errors.lol->list $(args) : $(2) : $(3) : $(4) :
+ $(5) : $(6) : $(7) : $(8) : $(9) ] "]" : Got: "[" \"$(result)\" "]" ;
     }
 }
 
 
-rule .set.equal ( set1 * : set2 * )
+# Assert that ELEMENT is present in LIST.
+#
+rule "in" ( element : list * )
 {
- if ( $(set1) in $(set2) ) && ( $(set2) in $(set1) )
+ if ! $(element) in $(list)
     {
- return true ;
+ errors.error-skip-frames 3 assertion failure: Expected \"$(element)\" in
+ "[" \"$(list)\" "]" ;
     }
 }
 
 
-# Assert that EXPECTED is equal to the result of calling RULE-NAME with the
-# given arguments.
+# Assert the inequality of A and B, ignoring trailing empty string elements.
 #
-rule result-equal ( expected * : rule-name args * : * )
+rule not-equal ( a * : b * )
 {
- local result ;
- module [ CALLER_MODULE ]
+ if $(a) = $(b)
     {
- modules.poke assert : result
- : [ $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ] ;
+ errors.error-skip-frames 3 assertion failure: \"$(a)\" "!=" \"$(b)\"
+ (ignoring trailing empty strings) ;
     }
+}
 
- if ! [ .set.equal $(result) : $(expected) ]
+
+# Assert that ELEMENT is not present in LIST.
+#
+rule not-in ( element : list * )
+{
+ if $(element) in $(list)
     {
- error-skip-frames 3 assertion failure: "[" $(rule-name)
- [ lol->list $(args) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ]
- "]"
- : expected: \"$(expected)\"
- : got: \"$(result)\" ;
+ errors.error-skip-frames 3 assertion failure: Did not expect
+ \"$(element)\" in "[" \"$(list)\" "]" ;
     }
 }
 
 
-# Assert that the given variable is nonempty.
+# Assert the inequality of A and B as sets.
 #
-rule nonempty-variable ( name )
+rule not-set-equal ( a * : b * )
 {
- local value = [ modules.peek [ CALLER_MODULE ] : $(name) ] ;
+ if [ set-equal-test $(a) : $(b) ]
+ {
+ errors.error-skip-frames 3 assertion failure: Expected "[" \"$(a)\" "]"
+ and "[" \"$(b)\" "]" to not be equal as sets ;
+ }
+}
+
 
- if ! $(value)-is-nonempty
+# Assert that A and B are not exactly equal, not ignoring trailing empty string
+# elements.
+#
+rule not-exact-equal ( a * : b * )
+{
+ if [ exact-equal-test $(a) : $(b) ]
     {
- error-skip-frames 3 assertion failure: expecting non-empty variable $(variable) ;
+ errors.error-skip-frames 3 assertion failure: \"$(a)\" "!=" \"$(b)\" ;
     }
 }
 
 
-# Assert that the result of calling RULE-NAME on the given arguments has a true
-# logical value (is neither an empty list nor all empty strings).
+# Assert that EXPECTED is the result of calling RULE-NAME with the given
+# arguments.
 #
-rule true ( rule-name args * : * )
+rule result ( expected * : rule-name args * : * )
 {
     local result ;
     module [ CALLER_MODULE ]
     {
- modules.poke assert : result
- : [ $(1) : $(2) : $(3) : $(4)
- : $(5) : $(6) : $(7) : $(8) : $(9) ] ;
+ modules.poke assert : result : [ $(2) : $(3) : $(4) : $(5) : $(6) : $(7)
+ : $(8) : $(9) ] ;
     }
 
- if ! $(result)
+ if $(result) != $(expected)
     {
- error-skip-frames 3 assertion failure: expecting true result from
- "[" $(rule-name)
- [ lol->list $(args) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ]
- "]" ;
+ errors.error-skip-frames 3 assertion failure: "[" $(rule-name) [
+ errors.lol->list $(args) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) :
+ $(9) ] "]" : Expected: "[" \"$(expected)\" "]" : Got: "["
+ \"$(result)\" "]" ;
     }
 }
 
 
-# Assert that the result of calling RULE-NAME on the given arguments has a false
-# logical value (is either an empty list or all empty strings).
+# Assert that EXPECTED is set-equal (i.e. duplicates and ordering are ignored)
+# to the result of calling RULE-NAME with the given arguments. Note that rules
+# called this way may accept at most 8 parameters.
 #
-rule false ( rule-name args * : * )
+rule result-equal ( expected * : rule-name args * : * )
+{
+ local result ;
+ module [ CALLER_MODULE ]
+ {
+ modules.poke assert : result : [ $(2) : $(3) : $(4) : $(5) : $(6) : $(7)
+ : $(8) : $(9) ] ;
+ }
+
+ if ! [ set-equal-test $(result) : $(expected) ]
+ {
+ errors.error-skip-frames 3 assertion failure: "[" $(rule-name) [
+ errors.lol->list $(args) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) :
+ $(9) ] "]" : Expected: "[" \"$(expected)\" "]" : Got: "["
+ \"$(result)\" "]" ;
+ }
+}
+
+
+# Assert the equality of A and B as sets.
+#
+rule set-equal ( a * : b * )
+{
+ if ! [ set-equal-test $(a) : $(b) ]
+ {
+ errors.error-skip-frames 3 assertion failure: Expected "[" \"$(a)\" "]"
+ and "[" \"$(b)\" "]" to be equal as sets ;
+ }
+}
+
+
+# Assert that the result of calling RULE-NAME on the given arguments has a true
+# logical value (is neither an empty list nor all empty strings).
+#
+rule true ( rule-name args * : * )
 {
     local result ;
     module [ CALLER_MODULE ]
@@ -122,35 +208,54 @@
             : $(7) : $(8) : $(9) ] ;
     }
 
- if $(result)
+ if ! $(result)
     {
- error-skip-frames 3 assertion failure: expecting false result from
- "[" $(rule-name) [ lol->list $(args) : $(2) : $(3) : $(4) : $(5) :
- $(6) : $(7) : $(8) : $(9) ] "]" : got [ lol->list $(result) ]
- instead ;
+ errors.error-skip-frames 3 assertion failure: Expected true result from
+ "[" $(rule-name) [ errors.lol->list $(args) : $(2) : $(3) : $(4) :
+ $(5) : $(6) : $(7) : $(8) : $(9) ] "]" ;
     }
 }
 
 
-# Assert that 'element' is present in 'list'.
+# Assert the exact equality of A and B, not ignoring trailing empty string
+# elements.
 #
-rule "in" ( element : list * )
+rule exact-equal ( a * : b * )
 {
- if ! $(element) in $(list)
+ if ! [ exact-equal-test $(a) : $(b) ]
     {
- error-skip-frames 3 assertion failure: expecting $(element) in
- "[" $(list) "]" ;
+ errors.error-skip-frames 3 assertion failure: \"$(a)\" "==" \"$(b)\" ;
     }
 }
 
 
-# Assert that 'element' is not present in 'list'.
+# Assert that the given variable is not an empty list.
 #
-rule not-in ( element : list * )
+rule nonempty-variable ( name )
 {
- if $(element) in $(list)
+ local value = [ modules.peek [ CALLER_MODULE ] : $(name) ] ;
+ if ! $(value)-is-not-empty
     {
- error-skip-frames 3 assertion failure: did not expect $(element) in
- "[" $(list) "]" ;
+ errors.error-skip-frames 3 assertion failure: Expected variable
+ \"$(name)\" not to be an empty list ;
     }
 }
+
+
+rule __test__ ( )
+{
+ # -------------------------
+ # assert.set-equal() tests.
+ # -------------------------
+
+ set-equal : ;
+ not-set-equal "" "" : ;
+ set-equal "" "" : "" ;
+ set-equal "" "" : "" "" ;
+ set-equal a b c : a b c ;
+ set-equal a b c : b c a ;
+ set-equal a b c a : a b c ;
+ set-equal a b c : a b c a ;
+ not-set-equal a b c : a b c d ;
+ not-set-equal a b c d : a b c ;
+}

Modified: trunk/tools/build/v2/util/container.jam
==============================================================================
--- trunk/tools/build/v2/util/container.jam (original)
+++ trunk/tools/build/v2/util/container.jam 2008-06-08 15:41:56 EDT (Sun, 08 Jun 2008)
@@ -151,7 +151,7 @@
     {
         local left = $(self.value[1-$(index)]) ;
         local right = $(self.value[$(index)-]) ;
- if $(right)-is-defined
+ if $(right)-is-not-empty
         {
             left = $(left[1--2]) ;
         }
@@ -192,7 +192,7 @@
     #
     rule empty ( )
     {
- if ! $(self.value)-is-defined
+ if ! $(self.value)-is-not-empty
         {
             return true ;
         }
@@ -248,6 +248,7 @@
     import "class" : new ;
 
     local v1 = [ new vector ] ;
+ assert.true $(v1).equal $(v1) ;
     assert.true $(v1).empty ;
     assert.result 0 : $(v1).size ;
     assert.result "[" "]" : $(v1).str ;
@@ -313,9 +314,13 @@
     assert.result 111 222 333 444 xxx : $(v7).get ;
 
     local v8 = [ new vector "" "" "" ] ;
- assert.true $(v7).equal $(v7) ;
- assert.result 3 : $(v8).size ;
+ assert.true $(v8).equal $(v8) ;
     assert.false $(v8).empty ;
+ assert.result 3 : $(v8).size ;
+ assert.result "" : $(v8).at 1 ;
+ assert.result "" : $(v8).at 2 ;
+ assert.result "" : $(v8).at 3 ;
+ assert.result : $(v8).at 4 ;
     $(v8).insert 2 : 222 ;
     assert.result 4 : $(v8).size ;
     assert.result "" 222 "" "" : $(v8).get ;

Modified: trunk/tools/build/v2/util/indirect.jam
==============================================================================
--- trunk/tools/build/v2/util/indirect.jam (original)
+++ trunk/tools/build/v2/util/indirect.jam 2008-06-08 15:41:56 EDT (Sun, 08 Jun 2008)
@@ -27,6 +27,7 @@
 # expected to be the module in which to invoke the rule by the 'call' rule
 # below. Otherwise, the rule will be invoked in the module of this rule's
 # caller.
+#
 rule make ( rulename bound-args * : context ? )
 {
     context ?= [ CALLER_MODULE ] ;
@@ -40,6 +41,7 @@
 # supplied, the result will be invoked (by 'call', below) in the module of the
 # caller. Otherwise, frames > 1 specifies additional call frames to back up in
 # order to find the module context.
+#
 rule make-qualified ( rulename bound-args * : frames ? )
 {
     if [ MATCH $(.pattern) : $(rulename) ]
@@ -59,6 +61,7 @@
 
 
 # Returns the module name in which the given indirect rule will be invoked.
+#
 rule get-module ( [indirect-rule] x )
 {
     local m = [ MATCH $(.pattern) : $(x) ] ;
@@ -71,6 +74,7 @@
 
 
 # Returns the rulename that will be called when x is invoked.
+#
 rule get-rule ( [indirect-rule] x )
 {
     local m = [ MATCH $(.pattern) : $(x) ] ;
@@ -79,6 +83,7 @@
 
 
 # Invoke the given indirect-rule.
+#
 rule call ( [indirect-rule] r args * : * )
 {
     return [ modules.call-in [ get-module $(r) ] : [ get-rule $(r) ] $(args)

Modified: trunk/tools/build/v2/util/path.jam
==============================================================================
--- trunk/tools/build/v2/util/path.jam (original)
+++ trunk/tools/build/v2/util/path.jam 2008-06-08 15:41:56 EDT (Sun, 08 Jun 2008)
@@ -510,7 +510,7 @@
 rule make-UNIX ( native )
 {
     # VP: I have no idea now 'native' can be empty here! But it can!
- if $(native) = ""
+ if ! $(native)
     {
         errors.error "Empty path passed to 'make-UNIX'" ;
     }
@@ -815,17 +815,17 @@
 
     # Test processing 'invalid' rooted paths with too many '..' path elements
     # that would place them before the root.
- assert.result "" : make "/.." ;
- assert.result "" : make "/../" ;
- assert.result "" : make "/../." ;
- assert.result "" : make "/.././" ;
- assert.result "" : make "/foo/../bar/giz/.././././../../." ;
- assert.result "" : make "/foo/../bar/giz/.././././../.././" ;
- assert.result "" : make "//foo/../bar/giz/.././././../../." ;
- assert.result "" : make "//foo/../bar/giz/.././././../.././" ;
- assert.result "" : make "\\\\foo/../bar/giz/.././././../../." ;
- assert.result "" : make "\\\\foo/../bar/giz/.././././../.././" ;
- assert.result "" : make "/..///.//..///.//..////foo///" ;
+ assert.result : make "/.." ;
+ assert.result : make "/../" ;
+ assert.result : make "/../." ;
+ assert.result : make "/.././" ;
+ assert.result : make "/foo/../bar/giz/.././././../../." ;
+ assert.result : make "/foo/../bar/giz/.././././../.././" ;
+ assert.result : make "//foo/../bar/giz/.././././../../." ;
+ assert.result : make "//foo/../bar/giz/.././././../.././" ;
+ assert.result : make "\\\\foo/../bar/giz/.././././../../." ;
+ assert.result : make "\\\\foo/../bar/giz/.././././../.././" ;
+ assert.result : make "/..///.//..///.//..////foo///" ;
 
     assert.result "foo\\bar\\giz" : native "foo/bar/giz" ;
     assert.result "foo" : native "foo" ;


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