[Boost-commit] svn:boost r64458 - in trunk/tools/build/v2: build tools

Subject: [Boost-commit] svn:boost r64458 - in trunk/tools/build/v2: build tools
From: ghost_at_[hidden]
Date: 2010-07-30 03:38:19

Author: vladimir_prus
Date: 2010-07-30 03:38:13 EDT (Fri, 30 Jul 2010)
New Revision: 64458
URL: http://svn.boost.org/trac/boost/changeset/64458

Log:
Port tools/stage.jam.

Added:
   trunk/tools/build/v2/tools/stage.py   (contents, props changed)
Text files modified: 
   trunk/tools/build/v2/build/property_set.py   |    17 ++++++++++++-                           
   trunk/tools/build/v2/build/targets.py        |    15 +++++++-----                            
   trunk/tools/build/v2/build/type.py           |     5 +++                                     
   trunk/tools/build/v2/build/virtual_target.py |    48 +++++++++++++++++++++++++-------------- 
   trunk/tools/build/v2/tools/builtin.py        |     2 +                                       
   5 files changed, 61 insertions(+), 26 deletions(-)

Modified: trunk/tools/build/v2/build/property_set.py
==============================================================================
--- trunk/tools/build/v2/build/property_set.py	(original)
+++ trunk/tools/build/v2/build/property_set.py	2010-07-30 03:38:13 EDT (Fri, 30 Jul 2010)
@@ -366,7 +366,7 @@
             # change the location of generated targets
             l = self.get ('<location>')
             if l:
-                computed = l
+                computed = l[0]
                 is_relative = False
 
             else:
@@ -394,7 +394,7 @@
                 is_relative = True
 
             self.target_path_ = (computed, is_relative)
-            
+
         return self.target_path_
                     
     def add (self, ps):
@@ -428,6 +428,19 @@
         
         return self.feature_map_.get(feature, [])
 
+    # FIXME: make this cached
+    def get_properties(self, feature):
+        """Returns all contained properties associated with 'feature'"""
+
+        if not isinstance(feature, b2.build.feature.Feature):
+            feature = b2.build.feature.get(feature)
+
+        result = []        
+        for p in self.all_:
+            if p.feature() == feature:
+                result.append(p)
+        return result
+    
     def __contains__(self, item):
         for p in self.all_set_:
             if p.feature().name() == "toolset":

Modified: trunk/tools/build/v2/build/targets.py
==============================================================================
--- trunk/tools/build/v2/build/targets.py	(original)
+++ trunk/tools/build/v2/build/targets.py	2010-07-30 03:38:13 EDT (Fri, 30 Jul 2010)
@@ -346,9 +346,6 @@
         self.default_build_ = default_build
        
         self.build_dir_ = None
-
-        if parent_project:
-            self.inherit (parent_project)
         
         # A cache of IDs
         self.ids_cache_ = {}
@@ -372,6 +369,10 @@
         # 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):
@@ -563,7 +564,7 @@
             value = os.path.join(self.location_, 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)
 
@@ -571,7 +572,7 @@
         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(parent_project.constants_[c])
+            self.add_constant(c, parent_project.constants_[c])
         
         # Import rules from parent 
         this_module = self.project_module()
@@ -1122,7 +1123,9 @@
                 # usage requirements.
                 source_targets = unique (source_targets)
 
-                result = self.construct (self.name_, source_targets, rproperties)
+                # 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]

Modified: trunk/tools/build/v2/build/type.py
==============================================================================
--- trunk/tools/build/v2/build/type.py	(original)
+++ trunk/tools/build/v2/build/type.py	2010-07-30 03:38:13 EDT (Fri, 30 Jul 2010)
@@ -14,6 +14,7 @@
 from b2.util.utility import replace_grist, os_name
 from b2.exceptions import *
 from b2.build import feature, property, scanner
+from b2.util import bjam_signature
 
 __re_hyphen = re.compile ('-')
 
@@ -53,7 +54,7 @@
     
 reset ()
 
-
+@bjam_signature((["type"], ["suffixes", "*"], ["base_type"]))
 def register (type, suffixes = [], base_type = None):
     """ Registers a target type, possibly derived from a 'base-type'. 
         If 'suffixes' are provided, they list all the suffixes that mean a file is of 'type'.
@@ -175,6 +176,7 @@
     # TODO: remove this method
     return is_derived (type, base)
 
+@bjam_signature((["type"], ["properties", "*"], ["suffix"]))
 def set_generated_target_suffix (type, properties, suffix):
     """ Sets a target suffix that should be used when generating target 
         of 'type' with the specified properties. Can be called with
@@ -209,6 +211,7 @@
 # should be used.
 #
 # Usage example: library names use the "lib" prefix on unix.
+@bjam_signature((["type"], ["properties", "*"], ["suffix"]))
 def set_generated_target_prefix(type, properties, prefix):
     set_generated_target_ps(0, type, properties, prefix)
 

Modified: trunk/tools/build/v2/build/virtual_target.py
==============================================================================
--- trunk/tools/build/v2/build/virtual_target.py	(original)
+++ trunk/tools/build/v2/build/virtual_target.py	2010-07-30 03:38:13 EDT (Fri, 30 Jul 2010)
@@ -65,6 +65,7 @@
 import re
 import os.path
 import string
+import types
 
 from b2.util import path, utility, set
 from b2.util.utility import add_grist, get_grist, ungrist, replace_grist, get_value
@@ -73,7 +74,8 @@
 from b2.exceptions import *
 import b2.build.type
 import b2.build.property_set as property_set
-import type
+
+import b2.build.property as property
 
 __re_starts_with_at = re.compile ('^@(.*)')
 
@@ -158,7 +160,7 @@
         if self.files_.has_key (path):
             return self.files_ [path]
 
-        file_type = type.type (file)
+        file_type = b2.build.type.type (file)
 
         result = FileTarget (file, file_type, project,
                              None, file_location)       
@@ -184,7 +186,7 @@
     # Returns all targets from 'targets' with types
     # equal to 'type' or derived from it.
     def select_by_type(self, type, targets):
-        return [t for t in targets if type.is_sybtype(t.type(), type)]
+        return [t for t in targets if b2.build.type.is_sybtype(t.type(), type)]
 
     def register_actual_name (self, actual_name, virtual_target):
         if self.actual_.has_key (actual_name):
@@ -231,7 +233,7 @@
         """ Appends the suffix appropriate to 'type/property_set' combination
             to the specified name and returns the result.
         """
-        suffix = type.generated_target_suffix (file_type, prop_set)
+        suffix = b2.build.type.generated_target_suffix (file_type, prop_set)
 
         if suffix:
             return specified_name + '.' + suffix
@@ -616,7 +618,10 @@
         self.path_ = path
 
     def __str__(self):
-        return self.name_ + "." + self.type_
+        if self.type_:
+            return self.name_ + "." + self.type_
+        else:
+            return self.name_
 
     def clone_with_different_type(self, new_type):
         return FileTarget(self.name_, new_type, self.project_,
@@ -677,13 +682,13 @@
         """
         if not self.path_:
             if self.action_:
-                p = self.action_.properties ()
-                target_path = p.target_path ()
+                p = self.action_.properties ()            
+                (target_path, relative_to_build_dir) = p.target_path ()
                 
-                if target_path [1] == True:
+                if relative_to_build_dir:
                     # Indicates that the path is relative to
                     # build dir.
-                    target_path = os.path.join (self.project_.build_dir (), target_path [0])
+                    target_path = os.path.join (self.project_.build_dir (), target_path)
                                 
                 # Store the computed path, so that it's not recomputed
                 # any more
@@ -717,6 +722,7 @@
     """
     def __init__ (self, manager, sources, action_name, prop_set):
         assert(isinstance(prop_set, property_set.PropertySet))
+        assert type(sources) == types.ListType
         self.sources_ = sources
         self.action_name_ = action_name
         if not prop_set:
@@ -815,7 +821,7 @@
 #                i = self.manager_.get_object (i)
                 
             if i.type ():
-                scanner = type.get_scanner (i.type (), prop_set)
+                scanner = b2.build.type.get_scanner (i.type (), prop_set)
 
             r = i.actualize (scanner)
             result.append (r)
@@ -938,7 +944,7 @@
     if not new_properties:
         new_properties = action.properties()
 
-    closed_action = action.__class__(action.sources(), new_action_name,
+    cloned_action = action.__class__(action.manager_, action.sources(), new_action_name,
                                      new_properties)
                           
     cloned_targets = []
@@ -1018,17 +1024,25 @@
         either directly or indirectly, and either as sources,
         or as dependency properties. Targets referred with
         dependency property are returned a properties, not targets."""
-        
+
         # Find directly referenced targets.
         deps = self.build_properties().dependency()
         all_targets = self.sources_ + deps
         
         # Find other subvariants.
         r = []
-        for t in all_targets:
-            if not t in result:
-                result.add(t)
-                r.append(t.creating_subvariant)
+        for e in all_targets:
+            if not e in result:
+                result.add(e)
+                if isinstance(e, property.Property):
+                    t = e.value()
+                else:
+                    t = e
+                                    
+                # FIXME: how can this be?
+                cs = t.creating_subvariant()
+                if cs:
+                    r.append(cs)
         r = unique(r)
         for s in r:
             if s != self:
@@ -1069,7 +1083,7 @@
     def compute_target_directories(self, target_type=None):
         result = []
         for t in self.created_targets():
-            if not target_type or type.is_derived(t.type(), target_type):
+            if not target_type or b2.build.type.is_derived(t.type(), target_type):
                 result.append(t.path())
 
         for d in self.other_dg_:

Modified: trunk/tools/build/v2/tools/builtin.py
==============================================================================
--- trunk/tools/build/v2/tools/builtin.py	(original)
+++ trunk/tools/build/v2/tools/builtin.py	2010-07-30 03:38:13 EDT (Fri, 30 Jul 2010)
@@ -724,3 +724,5 @@
 ### 
 
 get_manager().projects().add_rule("variant", variant)
+
+import stage

Added: trunk/tools/build/v2/tools/stage.py
==============================================================================
--- (empty file)
+++ trunk/tools/build/v2/tools/stage.py	2010-07-30 03:38:13 EDT (Fri, 30 Jul 2010)
@@ -0,0 +1,349 @@
+# Status: ported.
+# Base revision 64444.
+#
+# Copyright 2003 Dave Abrahams
+# Copyright 2005, 2006 Rene Rivera
+# Copyright 2002, 2003, 2004, 2005, 2006, 2010 Vladimir Prus
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+
+# This module defines the 'install' rule, used to copy a set of targets to a
+# single location.
+
+import b2.build.feature as feature
+import b2.build.targets as targets
+import b2.build.property as property
+import b2.build.property_set as property_set
+import b2.build.generators as generators
+import b2.build.virtual_target as virtual_target
+
+from b2.manager import get_manager
+from b2.util.sequence import unique
+from b2.util import bjam_signature
+
+import b2.build.type
+
+import os.path
+import re
+import types
+
+feature.feature('install-dependencies', ['off', 'on'], ['incidental'])
+feature.feature('install-type', [], ['free', 'incidental'])
+feature.feature('install-source-root', [], ['free', 'path'])
+feature.feature('so-version', [], ['free', 'incidental'])
+
+# If 'on', version symlinks for shared libraries will not be created. Affects
+# Unix builds only.
+feature.feature('install-no-version-symlinks', ['on'], ['optional', 'incidental'])
+
+class InstallTargetClass(targets.BasicTarget):
+
+    def update_location(self, ps):
+        """If <location> is not set, sets it based on the project data."""
+
+        loc = ps.get('location')
+        if not loc:
+            loc = os.path.join(self.project().get('location'), self.name())
+            ps = ps.add_raw(["<location>" + loc])
+
+        return ps
+
+    def adjust_properties(self, target, build_ps):
+        a = target.action()
+        properties = []
+        if a:
+            ps = a.properties()
+            properties = ps.all()
+            
+            # Unless <hardcode-dll-paths>true is in properties, which can happen
+            # only if the user has explicitly requested it, nuke all <dll-path>
+            # properties.
+
+            if build_ps.get('hardcode-dll-paths') != ['true']:
+                properties = [p for p in properties if p.feature().name() != 'dll-path']
+
+            # If any <dll-path> properties were specified for installing, add
+            # them.
+            properties.extend(build_ps.get_properties('dll-path'))
+
+            # Also copy <linkflags> feature from current build set, to be used
+            # for relinking.
+            properties.extend(build_ps.get_properties('linkflags'))
+
+            # Remove the <tag> feature on original targets.
+            # And <location>. If stage target has another stage target in
+            # sources, then we shall get virtual targets with the <location>
+            # property set.
+            properties = [p for p in properties
+                          if not p.feature().name() in ['tag', 'location']]
+
+        properties.extend(build_ps.get_properties('dependency'))
+
+        properties.extend(build_ps.get_properties('location'))
+        
+
+        properties.extend(build_ps.get_properties('install-no-version-symlinks'))
+
+        d = build_ps.get_properties('install-source-root')
+
+        # Make the path absolute: we shall use it to compute relative paths and
+        # making the path absolute will help.
+        if d:
+            p = d[0]
+            properties.append(property.Property(p.feature(), os.path.abspath(p.value())))
+
+        return property_set.create(properties)
+    
+
+    def construct(self, name, source_targets, ps):
+
+        source_targets = self.targets_to_stage(source_targets, ps)
+        ps = self.update_location(ps)
+
+        ename = ps.get('name')
+        if ename:
+            ename = ename[0]
+        if ename and len(source_targets) > 1:
+            get_manager().errors()("When <name> property is used in 'install', only one source is allowed")
+
+        result = []
+
+        for i in source_targets:
+
+            staged_targets = []
+            new_ps = self.adjust_properties(i, ps)
+
+            # See if something special should be done when staging this type. It
+            # is indicated by the presence of a special "INSTALLED_" type.
+            t = i.type()
+            if t and b2.build.type.registered("INSTALLED_" + t):
+
+                if ename:
+                    get_manager().errors()("In 'install': <name> property specified with target that requires relinking.")
+                else:
+                    (r, targets) = generators.construct(self.project(), name, "INSTALLED_" + t,
+                                                        new_ps, [i])
+                    assert isinstance(r, property_set.PropertySet)
+                    staged_targets.extend(targets)
+                    
+            else:
+                staged_targets.append(copy_file(self.project(), ename, i, new_ps))
+
+            if not staged_targets:
+                get_manager().errors()("Unable to generate staged version of " + i)
+
+            result.extend(get_manager().virtual_targets().register(t) for t in staged_targets)
+
+        return (property_set.empty(), result)
+
+    def targets_to_stage(self, source_targets, ps):
+        """Given the list of source targets explicitly passed to 'stage', returns the
+        list of targets which must be staged."""
+
+        result = []
+
+        # Traverse the dependencies, if needed.
+        if ps.get('install-dependencies') == ['on']:
+            source_targets = self.collect_targets(source_targets)
+
+        # Filter the target types, if needed.
+        included_types = ps.get('install-type')
+        for r in source_targets:
+            ty = r.type()
+            if ty:
+                # Do not stage searched libs.
+                if ty != "SEARCHED_LIB":
+                    if included_types:
+                        if self.include_type(ty, included_types):
+                            result.append(r)
+                    else:
+                        result.append(r)
+            elif not included_types:
+                # Don't install typeless target if there is an explicit list of
+                # allowed types.
+                result.append(r)
+
+        return result
+
+    # CONSIDER: figure out why we can not use virtual-target.traverse here.
+    #
+    def collect_targets(self, targets):
+        
+        s = [t.creating_subvariant() for t in targets]
+        s = unique(s)
+        
+        result = set(targets)
+        for i in s:
+            i.all_referenced_targets(result)
+           
+        result2 = []
+        for r in result:
+            if isinstance(r, property.Property):
+                
+                if r.feature().name() != 'use':
+                    result2.append(r.value())
+            else:
+                result2.append(r)
+        result2 = unique(result2)
+        return result2
+
+    # Returns true iff 'type' is subtype of some element of 'types-to-include'.
+    #
+    def include_type(self, type, types_to_include):
+        return any(b2.build.type.is_subtype(type, ti) for ti in types_to_include)
+
+# Creates a copy of target 'source'. The 'properties' object should have a
+# <location> property which specifies where the target must be placed.
+#
+def copy_file(project, name, source, ps):
+
+    if not name:
+        name = source.name()
+
+    relative = ""
+
+    new_a = virtual_target.NonScanningAction([source], "common.copy", ps)
+    source_root = ps.get('install-source-root')
+    if source_root:
+        source_root = source_root[0]
+        # Get the real path of the target. We probably need to strip relative
+        # path from the target name at construction.
+        path = os.path.join(source.path(), os.path.dirname(name))
+        # Make the path absolute. Otherwise, it would be hard to compute the
+        # relative path. The 'source-root' is already absolute, see the
+        # 'adjust-properties' method above.
+        path = os.path.abspath(path)
+
+        relative = os.path.relpath(path, source_root)
+
+    name = os.path.join(relative, os.path.basename(name))
+    return virtual_target.FileTarget(name, source.type(), project, new_a, exact=True)
+
+def symlink(name, project, source, ps):
+    a = virtual_target.Action([source], "symlink.ln", ps)
+    return virtual_target.FileTarget(name, source.type(), project, a, exact=True)
+
+def relink_file(project, source, ps):
+    action = source.action()
+    cloned_action = virtual_target.clone_action(action, project, "", ps)
+    targets = cloned_action.targets()
+    # We relink only on Unix, where exe or shared lib is always a single file.
+    assert len(targets) == 1
+    return targets[0]
+
+
+# Declare installed version of the EXE type. Generator for this type will cause
+# relinking to the new location.
+b2.build.type.register('INSTALLED_EXE', [], 'EXE')
+
+class InstalledExeGenerator(generators.Generator):
+
+    def __init__(self):
+        generators.Generator.__init__(self, "install-exe", False, ['EXE'], ['INSTALLED_EXE'])
+
+    def run(self, project, name, ps, source):
+
+        need_relink = False;
+
+        if ps.get('os') in ['NT', 'CYGWIN'] or ps.get('target-os') in ['windows', 'cygwin']:
+            # Never relink
+            pass
+        else:
+            # See if the dll-path properties are not changed during
+            # install. If so, copy, don't relink.
+            need_relink = ps.get('dll-path') != source[0].action().properties().get('dll-path')
+
+        if need_relink:
+            return [relink_file(project, source, ps)]
+        else:
+            return [copy_file(project, None, source[0], ps)]
+
+generators.register(InstalledExeGenerator())
+
+
+# Installing a shared link on Unix might cause a creation of versioned symbolic
+# links.
+b2.build.type.register('INSTALLED_SHARED_LIB', [], 'SHARED_LIB')
+
+class InstalledSharedLibGenerator(generators.Generator):
+
+    def __init__(self):
+        generators.Generator.__init__(self, 'install-shared-lib', False, ['SHARED_LIB'], ['INSTALLED_SHARED_LIB'])
+
+    def run(self, project, name, ps, source):
+
+        source = source[0]
+        if ps.get('os') in ['NT', 'CYGWIN'] or ps.get('target-os') in ['windows', 'cygwin']:
+            copied = copy_file(project, None, source, ps)
+            return [get_manager().virtual_targets().register(copied)]
+        else:
+            a = source.action()
+            if not a:
+                # Non-derived file, just copy.
+                copied = copy_file(project, source, ps)
+            else:
+
+                need_relink = ps.get('dll-path') != source.action().properties().get('dll-path')
+                
+                if need_relink:
+                    # Rpath changed, need to relink.
+                    copied = relink_file(project, source, ps)
+                else:
+                    copied = copy_file(project, None, source, ps)
+
+            result = [get_manager().virtual_targets().register(copied)]
+            # If the name is in the form NNN.XXX.YYY.ZZZ, where all 'X', 'Y' and
+            # 'Z' are numbers, we need to create NNN.XXX and NNN.XXX.YYY
+            # symbolic links.
+            m = re.match("(.*)\\.([0123456789]+)\\.([0123456789]+)\\.([0123456789]+)$",
+                         copied.name());
+            if m:
+                # Symlink without version at all is used to make
+                # -lsome_library work.
+                result.append(symlink(m.group(1), project, copied, ps))
+
+                # Symlinks of some libfoo.N and libfoo.N.M are used so that
+                # library can found at runtime, if libfoo.N.M.X has soname of
+                # libfoo.N. That happens when the library makes some binary
+                # compatibility guarantees. If not, it is possible to skip those
+                # symlinks.
+                if ps.get('install-no-version-symlinks') != ['on']:
+                
+                    result.append(symlink(m.group(1) + '.' + m.group(2), project, copied, ps))
+                    result.append(symlink(m.group(1) + '.' + m.group(2) + '.' + m.group(3),
+                                          project, copied, ps))
+
+            return result
+            
+generators.register(InstalledSharedLibGenerator())
+
+
+# Main target rule for 'install'.
+#
+@bjam_signature((["name"], ["sources", "*"], ["requirements", "*"],
+                 ["default_build", "*"], ["usage_requirements", "*"]))
+def install(name, sources, requirements, default_build, usage_requirements):
+
+    # Unless the user has explicitly asked us to hardcode dll paths, add
+    # <hardcode-dll-paths>false in requirements, to override default value.
+    if not '<hardcode-dll-paths>true' in requirements:
+        requirements.append('<hardcode-dll-paths>false')
+
+    if any(r.startswith('<tag>') for r in requirements):
+        get_manager().errors()("The <tag> property is not allowed for the 'install' rule")
+
+    from b2.manager import get_manager
+    t = get_manager().targets()
+    
+    project = get_manager().projects().current()
+        
+    return t.main_target_alternative(
+        InstallTargetClass(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)))
+
+get_manager().projects().add_rule("install", install)
+get_manager().projects().add_rule("stage", install)
+