src/libbson/boost/boost_1_53_0/tools/build/v2/tools/stage.py
# 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[0].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=[]):
requirements = 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)