cdec cleanup, remove bayesian stuff, parsing stuff

1 files changed, 0 insertions, 1401 deletions

diff --git a/jam-files/boost-build/build/targets.py b/jam-files/boost-build/build/targets.py
deleted file mode 100644
index a35612ce..00000000
--- a/jam-files/boost-build/build/targets.py
+++ /dev/null
@@ -1,1401 +0,0 @@
-# Status: ported.
-# Base revision: 64488
-
-# Copyright Vladimir Prus 2002-2007.
-# Copyright Rene Rivera 2006.
-#
-# Distributed under the Boost Software License, Version 1.0.
-#    (See accompanying file LICENSE_1_0.txt or copy at
-#          http://www.boost.org/LICENSE_1_0.txt)
-
-#   Supports 'abstract' targets, which are targets explicitly defined in Jamfile.
-#
-#   Abstract targets are represented by classes derived from 'AbstractTarget' class. 
-#   The first abstract target is 'project_target', which is created for each
-#   Jamfile, and can be obtained by the 'target' rule in the Jamfile's module.
-#   (see project.jam). 
-#
-#   Project targets keep a list of 'MainTarget' instances.
-#   A main target is what the user explicitly defines in a Jamfile. It is
-#   possible to have several definitions for a main target, for example to have
-#   different lists of sources for different platforms. So, main targets
-#   keep a list of alternatives.
-#
-#   Each alternative is an instance of 'AbstractTarget'. When a main target
-#   subvariant is defined by some rule, that rule will decide what class to
-#   use, create an instance of that class and add it to the list of alternatives
-#   for the main target.
-#
-#   Rules supplied by the build system will use only targets derived
-#   from 'BasicTarget' class, which will provide some default behaviour.
-#   There will be two classes derived from it, 'make-target', created by the
-#   'make' rule, and 'TypedTarget', created by rules such as 'exe' and 'dll'.
-
-#
-#                         +------------------------+
-#                         |AbstractTarget          |
-#                         +========================+
-#                         |name                    |
-#                         |project                 |                                   
-#                         |                        |                                   
-#                         |generate(properties) = 0|                                   
-#                         +-----------+------------+                                   
-#                                     |                                                
-#                                     ^                                                
-#                                    / \                                               
-#                                   +-+-+                                              
-#                                     |                                                
-#                                     |                                                
-#            +------------------------+------+------------------------------+          
-#            |                               |                              |          
-#            |                               |                              |          
-# +----------+-----------+            +------+------+                +------+-------+  
-# | project_target       |            | MainTarget  |                | BasicTarget  |  
-# +======================+ 1        * +=============+  alternatives  +==============+  
-# | generate(properties) |o-----------+ generate    |<>------------->| generate     |  
-# | main-target          |            +-------------+                | construct = 0|
-# +----------------------+                                           +--------------+  
-#                                                                           |          
-#                                                                           ^          
-#                                                                          / \         
-#                                                                         +-+-+        
-#                                                                           |          
-#                                                                           |          
-#                 ...--+----------------+------------------+----------------+---+      
-#                      |                |                  |                    |      
-#                      |                |                  |                    |      
-#               ... ---+-----+   +------+-------+   +------+------+    +--------+-----+
-#                            |   | TypedTarget  |   | make-target |    | stage-target |
-#                            .   +==============+   +=============+    +==============+
-#                            .   | construct    |   | construct   |    | construct    |
-#                                +--------------+   +-------------+    +--------------+
-
-import re
-import os.path
-import sys
-
-from b2.manager import get_manager
-
-from b2.util.utility import *
-import property, project, virtual_target, property_set, feature, generators, toolset
-from virtual_target import Subvariant
-from b2.exceptions import *
-from b2.util.sequence import unique
-from b2.util import path, bjam_signature
-from b2.build.errors import user_error_checkpoint
-
-import b2.build.build_request as build_request
-
-import b2.util.set
-_re_separate_target_from_properties = re.compile (r'^([^<]*)(/(<.*))?$')
-
-class TargetRegistry:
-    
-    def __init__ (self):
-        # All targets that are currently being built.
-        # Only the key is id (target), the value is the actual object.
-        self.targets_being_built_ = {}
-
-        # Current indent for debugging messages
-        self.indent_ = ""
-
-        self.debug_building_ = "--debug-building" in bjam.variable("ARGV")
-
-        self.targets_ = []
-
-    def main_target_alternative (self, target):
-        """ Registers the specified target as a main target alternatives.
-            Returns 'target'.
-        """
-        target.project ().add_alternative (target)
-        return target
-
-    def main_target_sources (self, sources, main_target_name, no_renaming=0):
-        """Return the list of sources to use, if main target rule is invoked
-        with 'sources'. If there are any objects in 'sources', they are treated
-        as main target instances, and the name of such targets are adjusted to
-        be '<name_of_this_target>__<name_of_source_target>'. Such renaming
-        is disabled is non-empty value is passed for 'no-renaming' parameter."""
-        result = []
-
-        for t in sources:
-
-            t = b2.util.jam_to_value_maybe(t)
-            
-            if isinstance (t, AbstractTarget):
-                name = t.name ()
-
-                if not no_renaming:
-                    name = main_target_name + '__' + name
-                    t.rename (name)
-
-                # Inline targets are not built by default.
-                p = t.project()
-                p.mark_targets_as_explicit([name])                    
-                result.append(name)
-
-            else:
-                result.append (t)
-
-        return result
-
-
-    def main_target_requirements(self, specification, project):
-        """Returns the requirement to use when declaring a main target,
-         which are obtained by
-         - translating all specified property paths, and
-         - refining project requirements with the one specified for the target
-        
-         'specification' are the properties xplicitly specified for a
-          main target
-         'project' is the project where the main taret is to be declared."""
-
-        specification.extend(toolset.requirements())
-
-        requirements = property_set.refine_from_user_input(
-            project.get("requirements"), specification,
-            project.project_module(), project.get("location"))
-
-        return requirements
-
-    def main_target_usage_requirements (self, specification, project):
-        """ Returns the use requirement to use when declaraing a main target,
-            which are obtained by
-            - translating all specified property paths, and
-            - adding project's usage requirements
-            specification:  Use-properties explicitly specified for a main target
-            project:        Project where the main target is to be declared
-        """
-        project_usage_requirements = project.get ('usage-requirements')
-
-        # We don't use 'refine-from-user-input' because I'm not sure if:
-        # - removing of parent's usage requirements makes sense
-        # - refining of usage requirements is not needed, since usage requirements
-        #   are always free.
-        usage_requirements = property_set.create_from_user_input(
-            specification, project.project_module(), project.get("location"))
-        
-        return project_usage_requirements.add (usage_requirements)
-
-    def main_target_default_build (self, specification, project):
-        """ Return the default build value to use when declaring a main target,
-            which is obtained by using specified value if not empty and parent's
-            default build attribute otherwise.
-            specification:  Default build explicitly specified for a main target
-            project:        Project where the main target is to be declared
-        """
-        if specification:
-            return property_set.create_with_validation(specification)
-        else:
-            return project.get ('default-build')
-
-    def start_building (self, main_target_instance):
-        """ Helper rules to detect cycles in main target references.
-        """
-        if self.targets_being_built_.has_key(id(main_target_instance)):
-            names = []
-            for t in self.targets_being_built_.values() + [main_target_instance]:
-                names.append (t.full_name())
-            
-            get_manager().errors()("Recursion in main target references\n")
-        
-        self.targets_being_built_[id(main_target_instance)] = main_target_instance
-
-    def end_building (self, main_target_instance):
-        assert (self.targets_being_built_.has_key (id (main_target_instance)))
-        del self.targets_being_built_ [id (main_target_instance)]
-
-    def create_typed_target (self, type, project, name, sources, requirements, default_build, usage_requirements):
-        """ Creates a TypedTarget with the specified properties.
-            The 'name', 'sources', 'requirements', 'default_build' and
-            'usage_requirements' are assumed to be in the form specified
-            by the user in Jamfile corresponding to 'project'.
-        """
-        return self.main_target_alternative (TypedTarget (name, project, type,
-            self.main_target_sources (sources, name),
-            self.main_target_requirements (requirements, project),
-            self.main_target_default_build (default_build, project),
-            self.main_target_usage_requirements (usage_requirements, project)))
-
-    def increase_indent(self):
-        self.indent_ += "    "
-
-    def decrease_indent(self):
-        self.indent_ = self.indent_[0:-4]
-
-    def logging(self):
-        return self.debug_building_
-
-    def log(self, message):
-        if self.debug_building_:
-            print self.indent_ + message
-
-    def push_target(self, target):
-        self.targets_.append(target)
-
-    def pop_target(self):
-        self.targets_ = self.targets_[:-1]
-
-    def current(self):
-        return self.targets_[0]
-
-
-class GenerateResult:
-    
-    def __init__ (self, ur=None, targets=None):
-        if not targets:
-            targets = []
-        
-        self.__usage_requirements = ur
-        self.__targets = targets
-        assert all(isinstance(t, virtual_target.VirtualTarget) for t in targets)
-
-        if not self.__usage_requirements:
-            self.__usage_requirements = property_set.empty ()
-
-    def usage_requirements (self):
-        return self.__usage_requirements
-
-    def targets (self):
-        return self.__targets
-    
-    def extend (self, other):
-        assert (isinstance (other, GenerateResult))
-        
-        self.__usage_requirements = self.__usage_requirements.add (other.usage_requirements ())
-        self.__targets.extend (other.targets ())
-
-class AbstractTarget:
-    """ Base class for all abstract targets.
-    """
-    def __init__ (self, name, project, manager = None):
-        """ manager:     the Manager object
-            name:        name of the target
-            project:     the project target to which this one belongs
-            manager:the manager object. If none, uses project.manager ()
-        """
-        assert (isinstance (project, ProjectTarget))
-        # Note: it might seem that we don't need either name or project at all.
-        # However, there are places where we really need it. One example is error
-        # messages which should name problematic targets. Another is setting correct
-        # paths for sources and generated files.
-        
-        # Why allow manager to be specified? Because otherwise project target could not derive
-        # from this class.
-        if manager:
-            self.manager_ = manager
-        else:
-            self.manager_ = project.manager ()
-
-        self.name_ = name
-        self.project_ = project        
-    
-    def manager (self):
-        return self.manager_
-    
-    def name (self):
-        """ Returns the name of this target.
-        """
-        return self.name_
-    
-    def project (self):
-        """ Returns the project for this target.
-        """
-        return self.project_
-    
-    def location (self):
-        """ Return the location where the target was declared.
-        """
-        return self.location_
-            
-    def full_name (self):
-        """ Returns a user-readable name for this target.
-        """
-        location = self.project ().get ('location')
-        return location + '/' + self.name_
-        
-    def generate (self, property_set):
-        """ Takes a property set.  Generates virtual targets for this abstract
-            target, using the specified properties, unless a different value of some
-            feature is required by the target. 
-            On success, returns a GenerateResult instance with:
-                - a property_set with the usage requirements to be
-                  applied to dependents 
-                - a list of produced virtual targets, which may be
-                   empty.  
-            If 'property_set' is empty, performs default build of this
-            target, in a way specific to derived class.
-        """
-        raise BaseException ("method should be defined in derived classes")
-    
-    def rename (self, new_name):
-        self.name_ = new_name
-
-class ProjectTarget (AbstractTarget):
-    """ Project target class (derived from 'AbstractTarget')
-
-        This class these responsibilities:
-        - maintaining a list of main target in this project and
-          building it
-
-        Main targets are constructed in two stages:
-        - When Jamfile is read, a number of calls to 'add_alternative' is made.
-          At that time, alternatives can also be renamed to account for inline
-          targets.
-        - The first time 'main-target' or 'has-main-target' rule is called,
-          all alternatives are enumerated an main targets are created.
-    """
-    def __init__ (self, manager, name, project_module, parent_project, requirements, default_build):
-        AbstractTarget.__init__ (self, name, self, manager)
-        
-        self.project_module_ = project_module
-        self.location_ = manager.projects().attribute (project_module, 'location')
-        self.requirements_ = requirements
-        self.default_build_ = default_build
-       
-        self.build_dir_ = None
-        
-        # A cache of IDs
-        self.ids_cache_ = {}
-        
-        # True is main targets have already been built.
-        self.built_main_targets_ = False
-        
-        # A list of the registered alternatives for this project.
-        self.alternatives_ = []
-
-        # A map from main target name to the target corresponding
-        # to it.
-        self.main_target_ = {}
-        
-        # Targets marked as explicit.
-        self.explicit_targets_ = set()
-
-        # Targets marked as always
-        self.always_targets_ = set()
-
-        # The constants defined for this project.
-        self.constants_ = {}
-
-        # Whether targets for all main target are already created.
-        self.built_main_targets_ = 0
-
-        if parent_project:
-            self.inherit (parent_project)
-
-
-    # TODO: This is needed only by the 'make' rule. Need to find the
-    # way to make 'make' work without this method.
-    def project_module (self):
-        return self.project_module_
-    
-    def get (self, attribute):
-        return self.manager().projects().attribute(
-            self.project_module_, attribute)
-
-    def build_dir (self):
-        if not self.build_dir_:
-            self.build_dir_ = self.get ('build-dir')
-            if not self.build_dir_:
-                self.build_dir_ = os.path.join(self.project_.get ('location'), 'bin')
-
-        return self.build_dir_
-
-    def generate (self, ps):
-        """ Generates all possible targets contained in this project.
-        """
-        self.manager_.targets().log(
-            "Building project '%s' with '%s'" % (self.name (), str(ps)))
-        self.manager_.targets().increase_indent ()
-        
-        result = GenerateResult ()
-                
-        for t in self.targets_to_build ():
-            g = t.generate (ps)
-            result.extend (g)
-            
-        self.manager_.targets().decrease_indent ()
-        return result
-
-    def targets_to_build (self):
-        """ Computes and returns a list of AbstractTarget instances which
-            must be built when this project is built.
-        """
-        result = []
-        
-        if not self.built_main_targets_:
-            self.build_main_targets ()
-        
-        # Collect all main targets here, except for "explicit" ones.
-        for n, t  in self.main_target_.iteritems ():
-            if not t.name () in self.explicit_targets_:
-                result.append (t)
-
-        # Collect all projects referenced via "projects-to-build" attribute.
-        self_location = self.get ('location')
-        for pn in self.get ('projects-to-build'):
-            result.append (self.find(pn + "/"))
-                        
-        return result
-
-    def mark_targets_as_explicit (self, target_names):
-        """Add 'target' to the list of targets in this project
-        that should be build only by explicit request."""
-        
-        # Record the name of the target, not instance, since this
-        # rule is called before main target instaces are created.
-        self.explicit_targets_.update(target_names)
-
-    def mark_targets_as_always(self, target_names):
-        self.always_targets_.update(target_names)
-    
-    def add_alternative (self, target_instance):
-        """ Add new target alternative.
-        """
-        if self.built_main_targets_:
-            raise IllegalOperation ("add-alternative called when main targets are already created for project '%s'" % self.full_name ())
-
-        self.alternatives_.append (target_instance)
-
-    def main_target (self, name):
-        if not self.built_main_targets_:
-            self.build_main_targets()
-
-        return self.main_target_[name]
-
-    def has_main_target (self, name):
-        """Tells if a main target with the specified name exists."""
-        if not self.built_main_targets_:
-            self.build_main_targets()
-
-        return self.main_target_.has_key(name)
-            
-    def create_main_target (self, name):
-        """ Returns a 'MainTarget' class instance corresponding to the 'name'.
-        """
-        if not self.built_main_targets_:
-            self.build_main_targets ()
-                        
-        return self.main_targets_.get (name, None)
-
-
-    def find_really(self, id):
-        """ Find and return the target with the specified id, treated
-            relative to self.
-        """
-        result = None        
-        current_location = self.get ('location')
-
-        __re_split_project_target = re.compile (r'(.*)//(.*)')
-        split = __re_split_project_target.match (id)
-
-        project_part = None
-        target_part = None
-
-        if split:
-            project_part = split.group (1)
-            target_part = split.group (2)
-
-        project_registry = self.project_.manager ().projects ()
-        
-        extra_error_message = ''
-        if project_part:
-            # There's explicit project part in id. Looks up the
-            # project and pass the request to it.
-            pm = project_registry.find (project_part, current_location)
-            
-            if pm:
-                project_target = project_registry.target (pm)
-                result = project_target.find (target_part, no_error=1)
-
-            else:
-                extra_error_message = "error: could not find project '$(project_part)'"
-
-        else:
-            # Interpret target-name as name of main target
-            # Need to do this before checking for file. Consider this:
-            #
-            #  exe test : test.cpp ;
-            #  install s : test : <location>. ;
-            #
-            # After first build we'll have target 'test' in Jamfile and file
-            # 'test' on the disk. We need target to override the file.
-            
-            result = None
-            if self.has_main_target(id):
-                result = self.main_target(id)
-
-            if not result:
-                result = FileReference (self.manager_, id, self.project_)
-                if not result.exists ():
-                    # File actually does not exist.
-                    # Reset 'target' so that an error is issued.
-                    result = None
-                    
-
-            if not result:
-                # Interpret id as project-id
-                project_module = project_registry.find (id, current_location)
-                if project_module:
-                    result = project_registry.target (project_module)
-                                    
-        return result
-
-    def find (self, id, no_error = False):
-        v = self.ids_cache_.get (id, None)
-        
-        if not v:
-            v = self.find_really (id)
-            self.ids_cache_ [id] = v
-
-        if v or no_error:
-            return v
-
-        raise BaseException ("Unable to find file or target named '%s'\nreferred from project at '%s'" % (id, self.get ('location')))
-
-    
-    def build_main_targets (self):
-        self.built_main_targets_ = True
-        
-        for a in self.alternatives_:
-            name = a.name ()
-            if not self.main_target_.has_key (name):
-                t = MainTarget (name, self.project_)
-                self.main_target_ [name] = t
-
-            if name in self.always_targets_:
-                a.always()
-            
-            self.main_target_ [name].add_alternative (a)
-
-    def add_constant(self, name, value, path=0):
-        """Adds a new constant for this project.
-
-        The constant will be available for use in Jamfile
-        module for this project. If 'path' is true,
-        the constant will be interpreted relatively
-        to the location of project.
-        """
-
-        if path:
-            l = self.location_
-            if not l:
-                # Project corresponding to config files do not have 
-                # 'location' attribute, but do have source location.
-                # It might be more reasonable to make every project have
-                # a location and use some other approach to prevent buildable
-                # targets in config files, but that's for later.
-                l = get('source-location')
-                
-            value = os.path.join(l, value)
-            # Now make the value absolute path
-            value = os.path.join(os.getcwd(), value)
-
-        self.constants_[name] = value
-        bjam.call("set-variable", self.project_module(), name, value)
-
-    def inherit(self, parent_project):
-        for c in parent_project.constants_:
-            # No need to pass the type. Path constants were converted to
-            # absolute paths already by parent.
-            self.add_constant(c, parent_project.constants_[c])
-        
-        # Import rules from parent 
-        this_module = self.project_module()
-        parent_module = parent_project.project_module()
-
-        rules = bjam.call("RULENAMES", parent_module)
-        if not rules:
-            rules = []
-        user_rules = [x for x in rules
-                      if x not in self.manager().projects().project_rules().all_names()]
-        if user_rules:
-            bjam.call("import-rules-from-parent", parent_module, this_module, user_rules)
-        
-class MainTarget (AbstractTarget):
-    """ A named top-level target in Jamfile.
-    """
-    def __init__ (self, name, project):
-        AbstractTarget.__init__ (self, name, project)    
-        self.alternatives_ = []
-        self.default_build_ = property_set.empty ()
-        
-    def add_alternative (self, target):
-        """ Add a new alternative for this target.
-        """
-        d = target.default_build ()
-        
-        if self.alternatives_ and self.default_build_ != d:
-            get_manager().errors()("default build must be identical in all alternatives\n"
-              "main target is '%s'\n"
-              "with '%s'\n"
-              "differing from previous default build: '%s'" % (self.full_name (), d.raw (), self.default_build_.raw ()))
-
-        else:
-            self.default_build_ = d
-
-        self.alternatives_.append (target)
-
-    def __select_alternatives (self, property_set, debug):
-        """ Returns the best viable alternative for this property_set
-            See the documentation for selection rules.
-            # TODO: shouldn't this be 'alternative' (singular)?
-        """
-        # When selecting alternatives we have to consider defaults,
-        # for example:
-        #    lib l : l.cpp : <variant>debug ;
-        #    lib l : l_opt.cpp : <variant>release ;
-        # won't work unless we add default value <variant>debug.
-        property_set = property_set.add_defaults ()
-        
-        # The algorithm: we keep the current best viable alternative.
-        # When we've got new best viable alternative, we compare it
-        # with the current one. 
-        best = None
-        best_properties = None
-                        
-        if len (self.alternatives_) == 0:
-            return None
-
-        if len (self.alternatives_) == 1:
-            return self.alternatives_ [0]
-
-        if debug:
-            print "Property set for selection:", property_set
-
-        for v in self.alternatives_:
-            properties = v.match (property_set, debug)
-                       
-            if properties is not None:
-                if not best:
-                    best = v
-                    best_properties = properties
-
-                else:
-                    if b2.util.set.equal (properties, best_properties):
-                        return None
-
-                    elif b2.util.set.contains (properties, best_properties):
-                        # Do nothing, this alternative is worse
-                        pass
-
-                    elif b2.util.set.contains (best_properties, properties):
-                        best = v
-                        best_properties = properties
-
-                    else:
-                        return None
-
-        return best
-
-    def apply_default_build (self, property_set):
-        return apply_default_build(property_set, self.default_build_)
-
-    def generate (self, ps):
-        """ Select an alternative for this main target, by finding all alternatives
-            which requirements are satisfied by 'properties' and picking the one with
-            longest requirements set.
-            Returns the result of calling 'generate' on that alternative.
-        """
-        self.manager_.targets ().start_building (self)
-
-        # We want composite properties in build request act as if
-        # all the properties it expands too are explicitly specified.
-        ps = ps.expand ()
-        
-        all_property_sets = self.apply_default_build (ps)
-
-        result = GenerateResult ()
-        
-        for p in all_property_sets:
-            result.extend (self.__generate_really (p))
-
-        self.manager_.targets ().end_building (self)
-
-        return result
-        
-    def __generate_really (self, prop_set):
-        """ Generates the main target with the given property set
-            and returns a list which first element is property_set object
-            containing usage_requirements of generated target and with
-            generated virtual target in other elements. It's possible
-            that no targets are generated.
-        """
-        best_alternative = self.__select_alternatives (prop_set, debug=0)
-
-        if not best_alternative:
-            # FIXME: revive.
-            # self.__select_alternatives(prop_set, debug=1)
-            self.manager_.errors()(
-                "No best alternative for '%s'.\n"
-                  % (self.full_name(),))
-
-        result = best_alternative.generate (prop_set)
-                    
-        # Now return virtual targets for the only alternative
-        return result
-    
-    def rename(self, new_name):
-        AbstractTarget.rename(self, new_name)
-        for a in self.alternatives_:
-            a.rename(new_name)
-
-class FileReference (AbstractTarget):
-    """ Abstract target which refers to a source file.
-        This is artificial creature; it's usefull so that sources to 
-        a target can be represented as list of abstract target instances.
-    """
-    def __init__ (self, manager, file, project):
-        AbstractTarget.__init__ (self, file, project)
-        self.file_location_ = None
-    
-    def generate (self, properties):
-         return GenerateResult (None, [
-             self.manager_.virtual_targets ().from_file (
-             self.name_, self.location(), self.project_) ])
-
-    def exists (self):
-        """ Returns true if the referred file really exists.
-        """
-        if self.location ():
-            return True
-        else:
-            return False
-
-    def location (self):
-        # Returns the location of target. Needed by 'testing.jam'
-        if not self.file_location_:
-            source_location = self.project_.get('source-location')
-            
-            for src_dir in source_location:
-                location = os.path.join(src_dir, self.name())
-                if os.path.isfile(location):
-                    self.file_location_ = src_dir
-                    self.file_path = location
-                    break
-
-        return self.file_location_
-
-def resolve_reference(target_reference, project):
-    """ Given a target_reference, made in context of 'project',
-    returns the AbstractTarget instance that is referred to, as well
-    as properties explicitly specified for this reference.
-    """
-    # Separate target name from properties override
-    split = _re_separate_target_from_properties.match (target_reference)
-    if not split:
-        raise BaseException ("Invalid reference: '%s'" % target_reference)
-    
-    id = split.group (1)
-    
-    sproperties = []
-    
-    if split.group (3):
-        sproperties = property.create_from_strings(feature.split(split.group(3)))
-        sproperties = feature.expand_composites(sproperties)
-        
-    # Find the target
-    target = project.find (id)
-    
-    return (target, property_set.create(sproperties))
-
-def generate_from_reference(target_reference, project, property_set):
-    """ Attempts to generate the target given by target reference, which
-    can refer both to a main target or to a file.
-    Returns a list consisting of
-    - usage requirements
-    - generated virtual targets, if any
-    target_reference:  Target reference
-    project:           Project where the reference is made
-    property_set:      Properties of the main target that makes the reference
-    """
-    target, sproperties = resolve_reference(target_reference, project)
-    
-    # Take properties which should be propagated and refine them
-    # with source-specific requirements.
-    propagated = property_set.propagated()
-    rproperties = propagated.refine(sproperties)
-    
-    return target.generate(rproperties)
-
-
-
-class BasicTarget (AbstractTarget):
-    """ Implements the most standard way of constructing main target
-        alternative from sources. Allows sources to be either file or
-        other main target and handles generation of those dependency
-        targets.
-    """
-    def __init__ (self, name, project, sources, requirements = None, default_build = None, usage_requirements = None):
-        AbstractTarget.__init__ (self, name, project)
-    
-        for s in sources:
-            if get_grist (s):
-                raise InvalidSource ("property '%s' found in the 'sources' parameter for '%s'" % (s, name))
-    
-        self.sources_ = sources
-        
-        if not requirements: requirements = property_set.empty ()
-        self.requirements_ = requirements
-
-        if not default_build: default_build = property_set.empty ()
-        self.default_build_ = default_build
-
-        if not usage_requirements: usage_requirements = property_set.empty ()
-        self.usage_requirements_ = usage_requirements
-        
-        # A cache for resolved references
-        self.source_targets_ = None
-        
-        # A cache for generated targets
-        self.generated_ = {}
-        
-        # A cache for build requests
-        self.request_cache = {}
-
-        # Result of 'capture_user_context' has everything. For example, if this
-        # target is declare as result of loading Jamfile which was loaded when
-        # building target B which was requested from A, then we'll have A, B and
-        # Jamroot location in context. We only care about Jamroot location, most
-        # of the times.
-        self.user_context_ = self.manager_.errors().capture_user_context()[-1:]
-
-        self.always_ = False
-
-    def always(self):
-        self.always_ = True
-        
-    def sources (self):
-        """ Returns the list of AbstractTargets which are used as sources.
-            The extra properties specified for sources are not represented.
-            The only used of this rule at the moment is the '--dump-tests'
-            feature of the test system.            
-        """
-        if self.source_targets_ == None:
-            self.source_targets_ = []
-            for s in self.sources_:
-                self.source_targets_.append(resolve_reference(s, self.project_)[0])
-
-        return self.source_targets_
-
-    def requirements (self):
-        return self.requirements_
-                        
-    def default_build (self):
-        return self.default_build_
-
-    def common_properties (self, build_request, requirements):
-        """ Given build request and requirements, return properties
-            common to dependency build request and target build
-            properties.
-        """
-        # For optimization, we add free unconditional requirements directly,
-        # without using complex algorithsm.
-        # This gives the complex algorithm better chance of caching results.        
-        # The exact effect of this "optimization" is no longer clear
-        free_unconditional = []
-        other = []
-        for p in requirements.all():
-            if p.feature().free() and not p.condition() and p.feature().name() != 'conditional':
-                free_unconditional.append(p)
-            else:
-                other.append(p)
-        other = property_set.create(other)
-                
-        key = (build_request, other)
-        if not self.request_cache.has_key(key):
-            self.request_cache[key] = self.__common_properties2 (build_request, other)
-
-        return self.request_cache[key].add_raw(free_unconditional)
-
-    # Given 'context' -- a set of already present properties, and 'requirements',
-    # decide which extra properties should be applied to 'context'. 
-    # For conditional requirements, this means evaluating condition. For 
-    # indirect conditional requirements, this means calling a rule. Ordinary
-    # requirements are always applied.
-    #
-    # Handles situation where evaluating one conditional requirements affects
-    # condition of another conditional requirements, for example:
-    #
-    #     <toolset>gcc:<variant>release <variant>release:<define>RELEASE
-    #
-    # If 'what' is 'refined' returns context refined with new requirements. 
-    # If 'what' is 'added' returns just the requirements that must be applied.
-    def evaluate_requirements(self, requirements, context, what):
-        # Apply non-conditional requirements. 
-        # It's possible that that further conditional requirement change 
-        # a value set by non-conditional requirements. For example:
-        #
-        #    exe a : a.cpp : <threading>single <toolset>foo:<threading>multi ;
-        # 
-        # I'm not sure if this should be an error, or not, especially given that
-        #
-        #    <threading>single 
-        #
-        # might come from project's requirements.
-        unconditional = feature.expand(requirements.non_conditional())
-
-        context = context.refine(property_set.create(unconditional))
-
-        # We've collected properties that surely must be present in common
-        # properties. We now try to figure out what other properties
-        # should be added in order to satisfy rules (4)-(6) from the docs.
-    
-        conditionals = property_set.create(requirements.conditional())
-
-        # It's supposed that #conditionals iterations
-        # should be enough for properties to propagate along conditions in any
-        # direction.
-        max_iterations = len(conditionals.all()) +\
-                         len(requirements.get("<conditional>")) + 1
-    
-        added_requirements = []
-        current = context
-    
-        # It's assumed that ordinary conditional requirements can't add
-        # <indirect-conditional> properties, and that rules referred
-        # by <indirect-conditional> properties can't add new 
-        # <indirect-conditional> properties. So the list of indirect conditionals
-        # does not change.
-        indirect = requirements.get("<conditional>")
-    
-        ok = 0
-        for i in range(0, max_iterations):
-
-            e = conditionals.evaluate_conditionals(current).all()[:]
-        
-            # Evaluate indirect conditionals.
-            for i in indirect:
-                i = b2.util.jam_to_value_maybe(i)
-                if callable(i):
-                    # This is Python callable, yeah.
-                    e.extend(i(current))
-                else:
-                    # Name of bjam function. Because bjam is unable to handle
-                    # list of Property, pass list of strings.
-                    br = b2.util.call_jam_function(i[1:], [str(p) for p in current.all()])
-                    if br:
-                        e.extend(property.create_from_strings(br))
-
-            if e == added_requirements:
-                # If we got the same result, we've found final properties.
-                ok = 1
-                break
-            else:
-                # Oops, results of evaluation of conditionals has changed.
-                # Also 'current' contains leftover from previous evaluation.
-                # Recompute 'current' using initial properties and conditional
-                # requirements.
-                added_requirements = e
-                current = context.refine(property_set.create(feature.expand(e)))
-
-        if not ok:
-            self.manager().errors()("Can't evaluate conditional properties "
-                                    + str(conditionals))
-
-    
-        if what == "added":
-            return property_set.create(unconditional + added_requirements)
-        elif what == "refined":
-            return current
-        else:
-            self.manager().errors("Invalid value of the 'what' parameter")
-
-    def __common_properties2(self, build_request, requirements):
-        # This guarantees that default properties are present
-        # in result, unless they are overrided by some requirement.
-        # TODO: There is possibility that we've added <foo>bar, which is composite
-        # and expands to <foo2>bar2, but default value of <foo2> is not bar2,
-        # in which case it's not clear what to do.
-        #
-        build_request = build_request.add_defaults()
-        # Featured added by 'add-default' can be composite and expand
-        # to features without default values -- so they are not added yet.
-        # It could be clearer/faster to expand only newly added properties
-        # but that's not critical.
-        build_request = build_request.expand()
-      
-        return self.evaluate_requirements(requirements, build_request,
-                                          "refined")
-    
-    def match (self, property_set, debug):
-        """ Returns the alternative condition for this alternative, if
-            the condition is satisfied by 'property_set'.
-        """
-        # The condition is composed of all base non-conditional properties.
-        # It's not clear if we should expand 'self.requirements_' or not.
-        # For one thing, it would be nice to be able to put
-        #    <toolset>msvc-6.0 
-        # in requirements.
-        # On the other hand, if we have <variant>release in condition it 
-        # does not make sense to require <optimization>full to be in
-        # build request just to select this variant.
-        bcondition = self.requirements_.base ()
-        ccondition = self.requirements_.conditional ()
-        condition = b2.util.set.difference (bcondition, ccondition)
-
-        if debug:
-            print "    next alternative: required properties:", [str(p) for p in condition]
-        
-        if b2.util.set.contains (condition, property_set.all()):
-
-            if debug:
-                print "        matched"
-            
-            return condition
-
-        else:
-            return None
-
-
-    def generate_dependency_targets (self, target_ids, property_set):
-        targets = []
-        usage_requirements = []
-        for id in target_ids:
-                    
-            result = generate_from_reference(id, self.project_, property_set)
-            targets += result.targets()
-            usage_requirements += result.usage_requirements().all()
-
-        return (targets, usage_requirements)        
-    
-    def generate_dependency_properties(self, properties, ps):
-        """ Takes a target reference, which might be either target id
-            or a dependency property, and generates that target using
-            'property_set' as build request.
-
-            Returns a tuple (result, usage_requirements).
-        """
-        result_properties = []
-        usage_requirements = []
-        for p in properties:
-                   
-            result = generate_from_reference(p.value(), self.project_, ps)
-
-            for t in result.targets():
-                result_properties.append(property.Property(p.feature(), t))
-            
-            usage_requirements += result.usage_requirements().all()
-
-        return (result_properties, usage_requirements)        
-
-        
-
-
-    @user_error_checkpoint
-    def generate (self, ps):
-        """ Determines final build properties, generates sources,
-        and calls 'construct'. This method should not be
-        overridden.
-        """
-        self.manager_.errors().push_user_context(
-            "Generating target " + self.full_name(), self.user_context_)
-        
-        if self.manager().targets().logging():
-            self.manager().targets().log(
-                "Building target '%s'" % self.name_)
-            self.manager().targets().increase_indent ()
-            self.manager().targets().log(
-                "Build request: '%s'" % str (ps.raw ()))
-            cf = self.manager().command_line_free_features()
-            self.manager().targets().log(
-                "Command line free features: '%s'" % str (cf.raw ()))            
-            self.manager().targets().log(
-                "Target requirements: %s'" % str (self.requirements().raw ()))
-            
-        self.manager().targets().push_target(self)
-
-        if not self.generated_.has_key(ps):
-
-            # Apply free features form the command line.  If user
-            # said 
-            #   define=FOO
-            # he most likely want this define to be set for all compiles.
-            ps = ps.refine(self.manager().command_line_free_features())            
-            rproperties = self.common_properties (ps, self.requirements_)
-
-            self.manager().targets().log(
-                "Common properties are '%s'" % str (rproperties))
-          
-            if rproperties.get("<build>") != ["no"]:
-                
-                result = GenerateResult ()
-
-                properties = rproperties.non_dependency ()
-
-                (p, u) = self.generate_dependency_properties (rproperties.dependency (), rproperties)
-                properties += p
-                assert all(isinstance(p, property.Property) for p in properties)
-                usage_requirements = u
-
-                (source_targets, u) = self.generate_dependency_targets (self.sources_, rproperties)
-                usage_requirements += u
-
-                self.manager_.targets().log(
-                    "Usage requirements for '%s' are '%s'" % (self.name_, usage_requirements))
-
-                # FIXME:
-
-                rproperties = property_set.create(properties + usage_requirements)
-                usage_requirements = property_set.create (usage_requirements)
-
-                self.manager_.targets().log(
-                    "Build properties: '%s'" % str(rproperties))
-                
-                source_targets += rproperties.get('<source>')
-                
-                # We might get duplicate sources, for example if
-                # we link to two library which have the same <library> in
-                # usage requirements.
-                # Use stable sort, since for some targets the order is
-                # important. E.g. RUN_PY target need python source to come
-                # first.
-                source_targets = unique(source_targets, stable=True)
-
-                # FIXME: figure why this call messes up source_targets in-place
-                result = self.construct (self.name_, source_targets[:], rproperties)
-
-                if result:
-                    assert len(result) == 2
-                    gur = result [0]
-                    result = result [1]
-
-                    if self.always_:
-                        for t in result:
-                            t.always()
-
-                    s = self.create_subvariant (
-                        result,
-                        self.manager().virtual_targets().recent_targets(), ps,
-                        source_targets, rproperties, usage_requirements)
-                    self.manager().virtual_targets().clear_recent_targets()
-                    
-                    ur = self.compute_usage_requirements (s)
-                    ur = ur.add (gur)
-                    s.set_usage_requirements (ur)
-
-                    self.manager_.targets().log (
-                        "Usage requirements from '%s' are '%s'" %
-                        (self.name(), str(rproperties)))
-                    
-                    self.generated_[ps] = GenerateResult (ur, result)
-                else:
-                    self.generated_[ps] = GenerateResult (property_set.empty(), [])
-            else:
-                # If we just see <build>no, we cannot produce any reasonable
-                # diagnostics. The code that adds this property is expected
-                # to explain why a target is not built, for example using
-                # the configure.log-component-configuration function.
-
-                # If this target fails to build, add <build>no to properties
-                # to cause any parent target to fail to build.  Except that it
-                # - does not work now, since we check for <build>no only in
-                #   common properties, but not in properties that came from
-                #   dependencies
-                # - it's not clear if that's a good idea anyway.  The alias
-                #   target, for example, should not fail to build if a dependency
-                #   fails.                
-                self.generated_[ps] = GenerateResult(
-                    property_set.create(["<build>no"]), [])
-        else:
-            self.manager().targets().log ("Already built")
-
-        self.manager().targets().pop_target()
-        self.manager().targets().decrease_indent()
-
-        return self.generated_[ps]
-    
-    def compute_usage_requirements (self, subvariant):
-        """ Given the set of generated targets, and refined build 
-            properties, determines and sets appripriate usage requirements
-            on those targets.
-        """
-        rproperties = subvariant.build_properties ()
-        xusage_requirements =self.evaluate_requirements(
-            self.usage_requirements_, rproperties, "added")
-        
-        # We generate all dependency properties and add them,
-        # as well as their usage requirements, to result.
-        (r1, r2) = self.generate_dependency_properties(xusage_requirements.dependency (), rproperties)
-        extra = r1 + r2
-                
-        result = property_set.create (xusage_requirements.non_dependency () + extra)
-
-        # Propagate usage requirements we've got from sources, except
-        # for the <pch-header> and <pch-file> features.
-        #
-        # That feature specifies which pch file to use, and should apply
-        # only to direct dependents. Consider:
-        #
-        #   pch pch1 : ...
-        #   lib lib1 : ..... pch1 ;
-        #   pch pch2 : 
-        #   lib lib2 : pch2 lib1 ;
-        #
-        # Here, lib2 should not get <pch-header> property from pch1.
-        #
-        # Essentially, when those two features are in usage requirements,
-        # they are propagated only to direct dependents. We might need
-        # a more general mechanism, but for now, only those two
-        # features are special.
-        raw = subvariant.sources_usage_requirements().raw()
-        raw = property.change(raw, "<pch-header>", None);
-        raw = property.change(raw, "<pch-file>", None);              
-        result = result.add(property_set.create(raw))
-        
-        return result
-
-    def create_subvariant (self, root_targets, all_targets,
-                           build_request, sources,
-                           rproperties, usage_requirements):
-        """Creates a new subvariant-dg instances for 'targets'
-         - 'root-targets' the virtual targets will be returned to dependents
-         - 'all-targets' all virtual 
-              targets created while building this main target
-         - 'build-request' is property-set instance with
-         requested build properties"""
-         
-        for e in root_targets:
-            e.root (True)
-
-        s = Subvariant (self, build_request, sources,
-                        rproperties, usage_requirements, all_targets)
-        
-        for v in all_targets:
-            if not v.creating_subvariant():
-                v.creating_subvariant(s)
-                
-        return s
-        
-    def construct (self, name, source_targets, properties):
-        """ Constructs the virtual targets for this abstract targets and
-            the dependecy graph. Returns a tuple consisting of the properties and the list of virtual targets.
-            Should be overrided in derived classes.
-        """
-        raise BaseException ("method should be defined in derived classes")
-
-
-class TypedTarget (BasicTarget):
-    import generators
-    
-    def __init__ (self, name, project, type, sources, requirements, default_build, usage_requirements):
-        BasicTarget.__init__ (self, name, project, sources, requirements, default_build, usage_requirements)
-        self.type_ = type
-
-    def __jam_repr__(self):
-        return b2.util.value_to_jam(self)
-    
-    def type (self):
-        return self.type_
-            
-    def construct (self, name, source_targets, prop_set):
-
-        r = generators.construct (self.project_, name, self.type_, 
-                                  prop_set.add_raw(['<main-target-type>' + self.type_]),
-                                  source_targets, True)
-
-        if not r:
-            print "warning: Unable to construct '%s'" % self.full_name ()
-
-            # Are there any top-level generators for this type/property set.
-            if not generators.find_viable_generators (self.type_, prop_set):
-                print "error: no generators were found for type '" + self.type_ + "'"
-                print "error: and the requested properties"
-                print "error: make sure you've configured the needed tools"
-                print "See http://boost.org/boost-build2/doc/html/bbv2/advanced/configuration.html"
-                
-                print "To debug this problem, try the --debug-generators option."
-                sys.exit(1)
-        
-        return r
-
-def apply_default_build(property_set, default_build):
-    # 1. First, see what properties from default_build
-    # are already present in property_set. 
-
-    specified_features = set(p.feature() for p in property_set.all())
-
-    defaults_to_apply = []
-    for d in default_build.all():
-        if not d.feature() in specified_features:
-            defaults_to_apply.append(d)
-
-    # 2. If there's any defaults to be applied, form the new
-    # build request. Pass it throw 'expand-no-defaults', since
-    # default_build might contain "release debug", which will
-    # result in two property_sets.
-    result = []
-    if defaults_to_apply:
-
-        # We have to compress subproperties here to prevent
-        # property lists like:
-        #
-        #    <toolset>msvc <toolset-msvc:version>7.1 <threading>multi
-        #
-        # from being expanded into:
-        #
-        #    <toolset-msvc:version>7.1/<threading>multi
-        #    <toolset>msvc/<toolset-msvc:version>7.1/<threading>multi
-        #
-        # due to cross-product property combination.  That may
-        # be an indication that
-        # build_request.expand-no-defaults is the wrong rule
-        # to use here.
-        compressed = feature.compress_subproperties(property_set.all())
-
-        result = build_request.expand_no_defaults(
-            b2.build.property_set.create([p]) for p in (compressed + defaults_to_apply))
-
-    else:
-        result.append (property_set)
-
-    return result
-
-
-def create_typed_metatarget(name, type, sources, requirements, default_build, usage_requirements):
-    
-    from b2.manager import get_manager
-    t = get_manager().targets()
-    
-    project = get_manager().projects().current()
-        
-    return t.main_target_alternative(
-        TypedTarget(name, project, type,
-                    t.main_target_sources(sources, name),
-                    t.main_target_requirements(requirements, project),
-                    t.main_target_default_build(default_build, project),
-                    t.main_target_usage_requirements(usage_requirements, project)))
-
-
-def create_metatarget(klass, name, sources, requirements=[], default_build=[], usage_requirements=[]):
-    from b2.manager import get_manager
-    t = get_manager().targets()
-    
-    project = get_manager().projects().current()
-        
-    return t.main_target_alternative(
-        klass(name, project,
-              t.main_target_sources(sources, name),
-              t.main_target_requirements(requirements, project),
-              t.main_target_default_build(default_build, project),
-              t.main_target_usage_requirements(usage_requirements, project)))    
-
-def metatarget_function_for_class(class_):
-
-    @bjam_signature((["name"], ["sources", "*"], ["requirements", "*"],
-                     ["default_build", "*"], ["usage_requirements", "*"]))
-    def create_metatarget(name, sources, requirements = [], default_build = None, usage_requirements = []):
-
-        from b2.manager import get_manager
-        t = get_manager().targets()
-
-        project = get_manager().projects().current()
-        
-        return t.main_target_alternative(
-            class_(name, project,
-                   t.main_target_sources(sources, name),
-                   t.main_target_requirements(requirements, project),
-                   t.main_target_default_build(default_build, project),
-                   t.main_target_usage_requirements(usage_requirements, project)))
-
-    return create_metatarget