Boost logo

Boost-Commit :

From: jurko.gospodnetic_at_[hidden]
Date: 2008-05-05 12:01:21


Author: jurko
Date: 2008-05-05 12:01:21 EDT (Mon, 05 May 2008)
New Revision: 45145
URL: http://svn.boost.org/trac/boost/changeset/45145

Log:
Removed some old corpse comments and debugging output code related to functionality long removed in revision 29361. Minor stylistic comment changes.
Text files modified:
   trunk/tools/build/v2/build/generators.jam | 75 +++++++++++++++++----------------------
   1 files changed, 32 insertions(+), 43 deletions(-)

Modified: trunk/tools/build/v2/build/generators.jam
==============================================================================
--- trunk/tools/build/v2/build/generators.jam (original)
+++ trunk/tools/build/v2/build/generators.jam 2008-05-05 12:01:21 EDT (Mon, 05 May 2008)
@@ -5,46 +5,37 @@
 # (See accompanying file LICENSE_1_0.txt or copy at
 # http://www.boost.org/LICENSE_1_0.txt)
 
-# Manages 'generators' --- objects which can do transformation between
-# different target types and contain algorithm for finding transformation from
-# sources to targets.
-#
-# The main entry point to this module is generators.construct rule. It is given
-# a list of source targets, desired target type and a set of properties. It
-# starts by selecting 'viable generators', which have any chances of producing
-# the desired target type with the required properties. Generators are ranked
-# and a set of the most specific ones is selected.
-#
-# The most specific generators have their 'run' methods called, with the
-# properties and list of sources. Each one selects a target which can be
-# directly consumed, and tries to convert the remaining ones to the types it
-# can consume. This is done by recursively calling 'construct' with all
-# consumable types.
-#
-# If the generator has collected all the targets it needs, it creates targets
-# corresponding to result, and returns it. When all generators have been run,
-# results of one of them are selected and returned as a result.
-#
-# It's quite possible that 'construct' returns more targets that it was asked
-# for. For example, it was asked to target type EXE, but the only found
-# generators produces both EXE and TDS (file with debug) information. The extra
-# target will be returned.
-#
-# Likewise, when generator tries to convert sources to consumable types, it can
-# get more targets that it was asked for. The question is what to do with extra
-# targets. Boost.Build attempts to convert them to requested types, and
-# attempts that as early as possible. Specifically, this is done after invoking
-# each generator. (Later I'll document the rationale for trying extra target
-# conversion at that point).
-#
-# That early conversion is not always desirable. Suppose a generator got a
-# source of type Y and must consume one target of type X_1 and one target of
-# type X_2. When converting Y to X_1 extra target of type Y_2 is created. We
-# should not try to convert it to type X_1, because if we do so, the generator
-# will get two targets of type X_1, and will be at loss as to which one to use.
-# Because of that, the 'construct' rule has a parameter, telling if multiple
-# targets can be returned. If the parameter is false, conversion of extra
-# targets is not performed.
+# Manages 'generators' --- objects which can do transformation between different
+# target types and contain algorithm for finding transformation from sources to
+# targets.
+#
+# The main entry point to this module is generators.construct rule. It is given
+# a list of source targets, desired target type and a set of properties. It
+# starts by selecting 'viable generators', which have any chances of producing
+# the desired target type with the required properties. Generators are ranked
+# and a set of the most specific ones is selected.
+#
+# The most specific generators have their 'run' methods called, with the
+# properties and list of sources. Each one selects a target which can be
+# directly consumed, and tries to convert the remaining ones to the types it can
+# consume. This is done by recursively calling 'construct' with all consumable
+# types.
+#
+# If the generator has collected all the targets it needs, it creates targets
+# corresponding to result, and returns it. When all generators have been run,
+# results of one of them are selected and returned as a result.
+#
+# It is quite possible for 'construct' to return more targets that it was asked
+# for. For example, if it were asked to generate a target of type EXE, but the
+# only found generator produces both EXE and TDS (file with debug) information.
+# The extra target will be returned.
+#
+# Likewise, when generator tries to convert sources to consumable types, it can
+# get more targets that it was asked for. The question is what to do with extra
+# targets. Boost.Build attempts to convert them to requested types, and attempts
+# that as early as possible. Specifically, this is done after invoking each
+# generator. TODO: An example is needed to document the rationale for trying
+# extra target conversion at that point.
 
 import "class" : new ;
 import errors ;
@@ -293,7 +284,6 @@
             )
     {
         generators.dout [ indent ] " ** generator" $(self.id) ;
- generators.dout [ indent ] " multiple:" $(mutliple) ;
         generators.dout [ indent ] " composing:" $(self.composing) ;
 
         if ! $(self.composing) && $(sources[2]) && $(self.source-types[2])
@@ -1163,8 +1153,7 @@
 
 # Attempts to create a target of 'target-type' with 'properties' from 'sources'.
 # The 'sources' are treated as a collection of *possible* ingridients -- i.e. it
-# is not required to consume them all. If 'multiple' is true, the rule is
-# allowed to return several targets of 'target-type'.
+# is not required to consume them all.
 #
 # Returns a list of targets. When this invocation is first instance of
 # 'construct' in stack, returns only targets of requested 'target-type',


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