Subject: [Boost-commit] svn:boost r64351 - in trunk/tools/build/v2: . build test util
From: ghost_at_[hidden]
Date: 2010-07-26 04:28:13
Author: vladimir_prus
Date: 2010-07-26 04:28:12 EDT (Mon, 26 Jul 2010)
New Revision: 64351
URL: http://svn.boost.org/trac/boost/changeset/64351
Log:
Major update of top level 'build_system.py' module.
Added:
trunk/tools/build/v2/util/option.py (contents, props changed)
Text files modified:
trunk/tools/build/v2/build/build_request.py | 6
trunk/tools/build/v2/build/targets.py | 20
trunk/tools/build/v2/build_system.py | 1021 ++++++++++++++++++++++++++++-----------
trunk/tools/build/v2/test/BoostBuild.py | 2
trunk/tools/build/v2/test/dll_path.py | 4
trunk/tools/build/v2/test/explicit.py | 4
trunk/tools/build/v2/util/path.py | 105 +--
7 files changed, 785 insertions(+), 377 deletions(-)
Modified: trunk/tools/build/v2/build/build_request.py
==============================================================================
--- trunk/tools/build/v2/build/build_request.py (original)
+++ trunk/tools/build/v2/build/build_request.py 2010-07-26 04:28:12 EDT (Mon, 26 Jul 2010)
@@ -7,7 +7,9 @@
# all copies. This software is provided "as is" without express or implied
# warranty, and with no claim as to its suitability for any purpose.
-import feature
+import b2.build.feature
+feature = b2.build.feature
+
from b2.util.utility import *
import b2.build.property_set as property_set
@@ -145,7 +147,7 @@
else:
result = [e1 + "/" + e2 for e1 in result for e2 in lresult]
- return result
+ return [property_set.create(b2.build.feature.split(r)) for r in result]
###
### rule __test__ ( )
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-26 04:28:12 EDT (Mon, 26 Jul 2010)
@@ -81,9 +81,11 @@
from virtual_target import Subvariant
from b2.exceptions import *
from b2.util.sequence import unique
-from b2.util import set, path, bjam_signature
+from b2.util import path, bjam_signature
from b2.build.errors import user_error_checkpoint
+import b2.util.set
+
_re_separate_target_from_properties = re.compile (r'^([^<]*)(/(<.*))?$')
class TargetRegistry:
@@ -357,7 +359,7 @@
self.main_target_ = {}
# Targets marked as explicit.
- self.explicit_targets_ = []
+ self.explicit_targets_ = set()
# The constants defined for this project.
self.constants_ = {}
@@ -426,7 +428,7 @@
# Record the name of the target, not instance, since this
# rule is called before main target instaces are created.
- self.explicit_.append(target_name)
+ self.explicit_targets_.add(target_name)
def add_alternative (self, target_instance):
""" Add new target alternative.
@@ -575,7 +577,7 @@
if not rules:
rules = []
user_rules = [x for x in rules
- if x not in self.manager().projects().project_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)
@@ -636,14 +638,14 @@
best_properties = properties
else:
- if set.equal (properties, best_properties):
+ if b2.util.set.equal (properties, best_properties):
return None
- elif set.contains (properties, best_properties):
+ elif b2.util.set.contains (properties, best_properties):
# Do nothing, this alternative is worse
pass
- elif set.contains (best_properties, properties):
+ elif b2.util.set.contains (best_properties, properties):
best = v
best_properties = properties
@@ -1006,12 +1008,12 @@
# build request just to select this variant.
bcondition = self.requirements_.base ()
ccondition = self.requirements_.conditional ()
- condition = set.difference (bcondition, ccondition)
+ condition = b2.util.set.difference (bcondition, ccondition)
if debug:
print " next alternative: required properties:", str(condition)
- if set.contains (condition, property_set.raw ()):
+ if b2.util.set.contains (condition, property_set.raw ()):
if debug:
print " matched"
Modified: trunk/tools/build/v2/build_system.py
==============================================================================
--- trunk/tools/build/v2/build_system.py (original)
+++ trunk/tools/build/v2/build_system.py 2010-07-26 04:28:12 EDT (Mon, 26 Jul 2010)
@@ -17,302 +17,542 @@
from b2.build.errors import ExceptionWithUserContext
import b2.tools.common
+import b2.build.project as project
+import b2.build.virtual_target as virtual_target
+import b2.build.build_request as build_request
+
+import b2.util.regex
+
+from b2.manager import get_manager
+from b2.util import cached
+from b2.util import option
+
+
import bjam
import os
import sys
+import re
-# FIXME:
-# Returns the location of the build system. The primary use case
-# is building Boost, where it's sometimes needed to get location
-# of other components (like BoostBook files), and it's convenient
-# to use location relatively to Boost.Build path.
-#rule location ( )
-#{
-# local r = [ modules.binding build-system ] ;
-# return $(r:P) ;
-#}
-
-# FIXME:
-
-def get_boolean_option(name):
- match = "--" + name
- if match in argv:
- return 1
- else:
- return 0
+################################################################################
+#
+# Module global data.
+#
+################################################################################
+
+# Flag indicating we should display additional debugging information related to
+# locating and loading Boost Build configuration files.
+debug_config = False
+
+# Legacy option doing too many things, some of which are not even documented.
+# Should be phased out.
+# * Disables loading site and user configuration files.
+# * Disables auto-configuration for toolsets specified explicitly on the
+# command-line.
+# * Causes --toolset command-line options to be ignored.
+# * Prevents the default toolset from being used even if no toolset has been
+# configured at all.
+legacy_ignore_config = False
+
+# The cleaning is tricky. Say, if user says 'bjam --clean foo' where 'foo' is a
+# directory, then we want to clean targets which are in 'foo' as well as those
+# in any children Jamfiles under foo but not in any unrelated Jamfiles. To
+# achieve this we collect a list of projects under which cleaning is allowed.
+project_targets = []
+
+# Virtual targets obtained when building main targets references on the command
+# line. When running 'bjam --clean main_target' we want to clean only files
+# belonging to that main target so we need to record which targets are produced
+# for it.
+results_of_main_targets = []
+
+# Was an XML dump requested?
+out_xml = False
+
+# Default toolset & version to be used in case no other toolset has been used
+# explicitly by either the loaded configuration files, the loaded project build
+# scripts or an explicit toolset request on the command line. If not specified,
+# an arbitrary default will be used based on the current host OS. This value,
+# while not strictly necessary, has been added to allow testing Boost-Build's
+# default toolset usage functionality.
+default_toolset = None
+default_toolset_version = None
+
+################################################################################
+#
+# Public rules.
+#
+################################################################################
+
+# Returns the property set with the free features from the currently processed
+# build request.
+#
+def command_line_free_features():
+ return command_line_free_features
+
+# Sets the default toolset & version to be used in case no other toolset has
+# been used explicitly by either the loaded configuration files, the loaded
+# project build scripts or an explicit toolset request on the command line. For
+# more detailed information see the comment related to used global variables.
+#
+def set_default_toolset(toolset, version=None):
+ default_toolset = toolset
+ default_toolset_version = version
-def get_string_option(name):
- match = "--" + name + "="
- for arg in argv:
- if arg.startswith(match):
- return arg[len(match):]
- return None
-
-def home_directories():
- if os.name == "nt":
- result = set()
- try:
- result.add(os.environ['HOMEDRIVE'] + os.environ['HOMEPATH'])
- result.add(os.environ['HOME'])
- result.add(os.environ['USERPROFILE'])
- except KeyError:
- pass
- return list(result)
- else:
- return [os.environ['HOME']]
+pre_build_hook = None
-ignore_config = 0
-debug_config = 0
+def set_pre_build_hook(callable):
+ pre_build_hook = callable
-def load_config(manager, basename, path):
- """Unless ignore-config is set, search configuration
- basename.jam in path and loads it. The jamfile module
- for that file will be loaded 'basename'."""
-
- if not ignore_config:
- found = glob(path, [basename + ".jam"])
- if found:
- found = found[0]
- if debug_config:
- print "notice: searching '%s' for '%s.jam'" % (path, basename)
- if found:
- print "notice: loading %s.jam from %s" % (basename, found)
+post_build_hook = None
- manager.projects().load_standalone(basename, found)
+def set_post_build_hook(callable):
+ post_build_hook = callable
-def main():
+################################################################################
+#
+# Local rules.
+#
+################################################################################
- global argv
- argv = bjam.variable("ARGV")
+# Returns actual Jam targets to be used for executing a clean request.
+#
+def actual_clean_targets(targets):
- # FIXME: document this option.
- if "--profiling" in argv:
- import cProfile
- import pstats
- cProfile.runctx('main_real()', globals(), locals(), "stones.prof")
-
- stats = pstats.Stats("stones.prof")
- stats.strip_dirs()
- stats.sort_stats('time', 'calls')
- stats.print_callers(20)
+ # Construct a list of projects explicitly detected as targets on this build
+ # system run. These are the projects under which cleaning is allowed.
+ for t in targets:
+ if isinstance(t, b2.build.targets.ProjectTarget):
+ project_targets.append(t.project_module())
+
+
+ # Construct a list of targets explicitly detected on this build system run
+ # as a result of building main targets.
+ targets_to_clean = set()
+ for t in results_of_main_targets:
+ # Do not include roots or sources.
+ targets_to_clean.update(virtual_target.traverse(t))
+
+ to_clean = []
+ for t in get_manager().virtual_targets().all_targets():
+
+ # Remove only derived targets.
+ if t.action():
+ p = t.project()
+ if t in targets_to_clean or should_clean_project(p.project_module()):
+ to_clean.append(t)
+
+ return [t.actualize() for t in to_clean]
+
+_target_id_split = re.compile("(.*)//(.*)")
+
+# Given a target id, try to find and return the corresponding target. This is
+# only invoked when there is no Jamfile in ".". This code somewhat duplicates
+# code in project-target.find but we can not reuse that code without a
+# project-targets instance.
+#
+def _find_target(target_id):
+
+ m = _target_id_split(target_id)
+ if m:
+ pm = project.find(m.group(1), ".")
else:
- main_real()
+ pm = project.find(target_id, ".")
-def main_real():
+ if pm:
+ result = project.target(pm)
- global ignore_config
- global debug_config
-
- boost_build_path = bjam.variable("BOOST_BUILD_PATH")
+ if m:
+ result = result.find(m.group(2))
- engine = Engine()
+ return result
- global_build_dir = get_string_option("build-dir")
- debug_config = get_boolean_option("debug-configuration")
-
- manager = Manager(engine, global_build_dir)
+def initialize_config_module(module_name):
- # This module defines types and generator and what not,
- # and depends on manager's existence
- import b2.tools.builtin
+ get_manager().projects().initialize(module_name)
+# Helper rule used to load configuration files. Loads the first configuration
+# file with the given 'filename' at 'path' into module with name 'module-name'.
+# Not finding the requested file may or may not be treated as an error depending
+# on the must-find parameter. Returns a normalized path to the loaded
+# configuration file or nothing if no file was loaded.
+#
+def load_config(module_name, filename, paths, must_find=False):
- # Check if we can load 'test-config.jam'. If we can, load it and
- # ignore user configs.
-
- test_config = glob(boost_build_path, ["test-config.jam"])
- if test_config:
- test_config = test_config[0]
+ if debug_config:
+ print "notice: Searching '%s' for '%s' configuration file '%s." \
+ % (paths, module_name, filename)
- if test_config:
+ where = None
+ for path in paths:
+ t = os.path.join(path, filename)
+ if os.path.exists(t):
+ where = t
+ break
+
+ if where:
+ where = os.path.realpath(where)
+
if debug_config:
- print "notice: loading testing-config.jam from '%s'" % test_config
- print "notice: user-config.jam and site-config.jam will be ignored"
+ print "notice: Loading '%s' configuration file '%s' from '%s'." \
+ % (module_name, filename, where)
- manager.projects().load_standalone("test-config", test_config)
+ # Set source location so that path-constant in config files
+ # with relative paths work. This is of most importance
+ # for project-config.jam, but may be used in other
+ # config files as well.
+ attributes = get_manager().projects().attributes(module_name) ;
+ attributes.set('source-location', os.path.dirname(where), True)
+ get_manager().projects().load_standalone(module_name, where)
+
+ else:
+ msg = "Configuration file '%s' not found in '%s'." % (filename, path)
+ if must_find:
+ get_manager().errors()(msg)
+
+ elif debug_config:
+ print msg
+
+ return where
+
+# Loads all the configuration files used by Boost Build in the following order:
+#
+# -- test-config --
+# Loaded only if specified on the command-line using the --test-config
+# command-line parameter. It is ok for this file not to exist even if specified.
+# If this configuration file is loaded, regular site and user configuration
+# files will not be. If a relative path is specified, file is searched for in
+# the current folder.
+#
+# -- site-config --
+# Always named site-config.jam. Will only be found if located on the system
+# root path (Windows), /etc (non-Windows), user's home folder or the Boost Build
+# path, in that order. Not loaded in case the test-config configuration file is
+# loaded or either the --ignore-site-config or the --ignore-config command-line
+# option is specified.
+#
+# -- user-config --
+# Named user-config.jam by default or may be named explicitly using the
+# --user-config command-line option or the BOOST_BUILD_USER_CONFIG environment
+# variable. If named explicitly the file is looked for from the current working
+# directory and if the default one is used then it is searched for in the
+# user's home directory and the Boost Build path, in that order. Not loaded in
+# case either the test-config configuration file is loaded, --ignore-config
+# command-line option is specified or an empty file name is explicitly
+# specified. If the file name has been given explicitly then the file must
+# exist.
+#
+# Test configurations have been added primarily for use by Boost Build's
+# internal unit testing system but may be used freely in other places as well.
+#
+def load_configuration_files():
+
+ # Flag indicating that site configuration should not be loaded.
+ ignore_site_config = "--ignore-site-config" in sys.argv
+ if legacy_ignore_config and debug_config:
+ print "notice: Regular site and user configuration files will be ignored"
+ print "notice: due to the --ignore-config command-line option."
+
+ initialize_config_module("test-config")
+ test_config = None
+ for a in sys.argv:
+ m = re.match("--test-config=(.*)$", a)
+ if m:
+ test_config = b2.util.unquote(m.group(1))
+ break
- ignore_config = test_config or get_boolean_option("ignore-config")
- user_path = home_directories() + boost_build_path
+ if test_config:
+ where = load_config("test-config", os.path.basename(test_config), [os.path.dirname(test_config)])
+ if where:
+ if debug_config and not legacy_ignore_config:
+ print "notice: Regular site and user configuration files will"
+ print "notice: be ignored due to the test configuration being loaded."
+ user_path = [os.path.expanduser("~")] + os.getenv("BOOST_BUILD_PATH").split(os.pathsep)
site_path = ["/etc"] + user_path
- if bjam.variable("OS") in ["NT", "CYGWIN"]:
- site_path = [os.environ("SystemRoot")] + user_path
+ if os.name in ["nt"]:
+ site_path = [os.getenv("SystemRoot")] + user_path
- load_config(manager, "site-config", site_path)
+ if ignore_site_config and not legacy_ignore_config:
+ print "notice: Site configuration files will be ignored due to the"
+ print "notice: --ignore-site-config command-line option."
+
+ initialize_config_module("site-config")
+ if not test_config and not ignore_site_config and not legacy_ignore_config:
+ load_config('site-config', 'site-config.jam', site_path)
+
+ initialize_config_module('user-config')
+ if not test_config and not legacy_ignore_config:
+
+ user_config = None
+ for a in sys.argv:
+ m = re.match("--user-config=(.*)$", a)
+ if m:
+ user_config = m.group(1)
+ break
- user_config_path = get_string_option("user-config")
- if not user_config_path:
- user_config_path = os.environ.get("BOOST_BUILD_USER_CONFIG")
+ if not user_config:
+ user_config = os.getenv("BOOST_BUILD_USER_CONFIG")
+
+ # Special handling for the case when the OS does not strip the quotes
+ # around the file name, as is the case when using Cygwin bash.
+ user_config = b2.util.unquote(user_config)
+ explicitly_requested = user_config
+ if not user_config:
+ user_config = "user-config.jam"
- if user_config_path:
- if debug_config:
- print "Loading explicitly specifier user configuration file:"
- print " %s" % user_config_path
+ if explicitly_requested:
+
+ user_config = os.path.abspath(user_config)
- manager.projects().load_standalone("user-config", user_config_path)
+ if debug_config:
+ print "notice: Loading explicitly specified user configuration file:"
+ print " " + user_config
+
+ load_config('user-config', os.path.basename(user_config), [os.path.dirname(user_config)], True)
+ else:
+ load_config('user-config', os.path.basename(user_config), user_path)
- else:
- load_config(manager, "user-config", user_path)
+ elif debug_config:
+ print "notice: User configuration file loading explicitly disabled." ;
+ # We look for project-config.jam from "." upward.
+ # I am not sure this is 100% right decision, we might as well check for
+ # it only alonside the Jamroot file. However:
+ #
+ # - We need to load project-root.jam before Jamroot
+ # - We probably would need to load project-root.jam even if there's no
+ # Jamroot - e.g. to implement automake-style out-of-tree builds.
+ if os.path.exists("project-config.jam"):
+ file = ["project-config.jam"]
+ else:
+ file = b2.util.path.glob_in_parents(".", ["project-config.jam"])
-# FIXME:
-## #
-## # Autoconfigure toolsets based on any instances of --toolset=xx,yy,...zz or
-## # toolset=xx,yy,...zz in the command line
-## #
-## local option-toolsets = [ regex.split-list [ MATCH ^--toolset=(.*) : $(argv) ] : "," ] ;
-## local feature-toolsets = [ regex.split-list [ MATCH ^toolset=(.*) : $(argv) ] : "," ] ;
-
-## # if the user specified --toolset=..., we need to add toolset=... to
-## # the build request
-## local extra-build-request ;
-
- extra_build_request = []
-
-## if ! $(ignore-config)
-## {
-## for local t in $(option-toolsets) $(feature-toolsets)
-## {
-## # Parse toolset-version/properties
-## local (t-v,t,v) = [ MATCH (([^-/]+)-?([^/]+)?)/?.* : $(t) ] ;
-## local toolset-version = $((t-v,t,v)[1]) ;
-## local toolset = $((t-v,t,v)[2]) ;
-## local version = $((t-v,t,v)[3]) ;
+ if file:
+ initialize_config_module('project-config')
+ load_config('project-config', "project-config.jam", [os.path.dirname(file[0])], True)
-## if $(debug-config)
-## {
-## ECHO notice: [cmdline-cfg] Detected command-line request for
-## $(toolset-version): toolset= \"$(toolset)\" "version= \""$(version)\" ;
-## }
-## local known ;
+# Autoconfigure toolsets based on any instances of --toolset=xx,yy,...zz or
+# toolset=xx,yy,...zz in the command line. May return additional properties to
+# be processed as if they had been specified by the user.
+#
+def process_explicit_toolset_requests():
-## # if the toolset isn't known, configure it now.
-## if $(toolset) in [ feature.values <toolset> ]
-## {
-## known = true ;
-## }
+ extra_properties = []
-## if $(known) && $(version)
-## && ! [ feature.is-subvalue toolset : $(toolset) : version : $(version) ]
-## {
-## known = ;
-## }
+ option_toolsets = [e for option in b2.util.regex.transform(sys.argv, "^--toolset=(.*)$")
+ for e in option.split(',')]
+ feature_toolsets = [e for option in b2.util.regex.transform(sys.argv, "^toolset=(.*)$")
+ for e in option.split(',')]
-## if ! $(known)
-## {
-## if $(debug-config)
-## {
-## ECHO notice: [cmdline-cfg] toolset $(toolset-version)
-## not previously configured; configuring now ;
-## }
-## toolset.using $(toolset) : $(version) ;
-## }
-## else
-## {
-## if $(debug-config)
-## {
-## ECHO notice: [cmdline-cfg] toolset $(toolset-version) already configured ;
-## }
-## }
+ for t in option_toolsets + feature_toolsets:
+
+ # Parse toolset-version/properties.
+ (toolset_version, toolset, version) = re.match("(([^-/]+)-?([^/]+)?)/?.*", t).groups()
-## # make sure we get an appropriate property into the build request in
-## # case the user used the "--toolset=..." form
-## if ! $(t) in $(argv)
-## && ! $(t) in $(feature-toolsets)
-## {
-## if $(debug-config)
-## {
-## ECHO notice: [cmdline-cfg] adding toolset=$(t) "to build request." ;
-## }
-## extra-build-request += toolset=$(t) ;
-## }
-## }
-## }
+ if debug_config:
+ print "notice: [cmdline-cfg] Detected command-line request for '%s': toolset= %s version=%s" \
+ % (toolset_version, toolset, version)
+ # If the toolset is not known, configure it now.
+ known = False
+ if toolset in feature.values("toolset"):
+ known = True
+
+ if known and version and not feature.is_subvalue("toolset", toolset, "version", version):
+ known = False
+ # TODO: we should do 'using $(toolset)' in case no version has been
+ # specified and there are no versions defined for the given toolset to
+ # allow the toolset to configure its default version. For this we need
+ # to know how to detect whether a given toolset has any versions
+ # defined. An alternative would be to do this whenever version is not
+ # specified but that would require that toolsets correctly handle the
+ # case when their default version is configured multiple times which
+ # should be checked for all existing toolsets first.
+
+ if not known:
+
+ if debug_config:
+ print "notice: [cmdline-cfg] toolset '%s' not previously configured; attempting to auto-configure now" % toolset_version
+ toolset.using(toolset, version)
-# FIXME:
-## if USER_MODULE in [ RULENAMES ]
-## {
-## USER_MODULE site-config user-config ;
-## }
+ else:
- if get_boolean_option("version"):
- # FIXME: Move to a separate module. Include bjam
- # verision.
- print "Boost.Build M15 (Python port in development)"
- sys.exit(0)
+ if debug_config:
- b2.tools.common.init(manager)
+ print "notice: [cmdline-cfg] toolset '%s' already configured" % toolset_version
- # We always load project in "." so that 'use-project' directives has
- # any chance of been seen. Otherwise, we won't be able to refer to
- # subprojects using target ids.
+ # Make sure we get an appropriate property into the build request in
+ # case toolset has been specified using the "--toolset=..." command-line
+ # option form.
+ if not t in sys.argv and not t in feature_toolsets:
- current_project = None
- projects = manager.projects()
- if projects.find(".", "."):
- current_project = projects.target(projects.load("."))
+ if debug_config:
+ print "notice: [cmdline-cfg] adding toolset=%s) to the build request." % t ;
+ extra_properties += "toolset=%s" % t
- # FIXME: revive this logic, when loading of gcc works
- if not feature.values("<toolset>") and not ignore_config and 0:
- default_toolset = "gcc" ;
- if bjam.variable("OS") == "NT":
- default_toolset = "msvc"
-
- print "warning: No toolsets are configured." ;
- print "warning: Configuring default toolset '%s'" % default_toolset
- print "warning: If the default is wrong, you may not be able to build C++ programs."
- print "warning: Use the \"--toolset=xxxxx\" option to override our guess."
- print "warning: For more configuration options, please consult"
- print "warning: http://boost.org/boost-build2/doc/html/bbv2/advanced/configuration.html"
+ return extra_properties
- projects.project_rules().using([default_toolset])
- (target_ids, properties) = b2.build.build_request.from_command_line(
- argv[1:] + extra_build_request)
- properties = [property_set.create(feature.split(ps)) for ps in properties]
+# Returns 'true' if the given 'project' is equal to or is a (possibly indirect)
+# child to any of the projects requested to be cleaned in this build system run.
+# Returns 'false' otherwise. Expects the .project-targets list to have already
+# been constructed.
+#
+@cached
+def should_clean_project(project):
- if properties:
- expanded = b2.build.build_request.expand_no_defaults(properties)
+ if project in project_targets:
+ return True
else:
- expanded = [property_set.empty()]
- targets = []
-
- clean = get_boolean_option("clean")
- clean_all = get_boolean_option("clean-all")
+ parent = get_manager().projects().attribute(project, "parent-module")
+ if parent and parent != "user-config":
+ return should_clean_project(parent)
+ else:
+ return False
+
+################################################################################
+#
+# main()
+# ------
+#
+################################################################################
+
+def main():
+
+ sys.argv = bjam.variable("ARGV")
+
+ # FIXME: document this option.
+ if "--profiling" in sys.argv:
+ import cProfile
+ import pstats
+ cProfile.runctx('main_real()', globals(), locals(), "stones.prof")
+
+ stats = pstats.Stats("stones.prof")
+ stats.strip_dirs()
+ stats.sort_stats('time', 'calls')
+ stats.print_callers(20)
+ else:
+ main_real()
+
+def main_real():
+
+ global debug_config, legacy_ignore_config, out_xml
+
+ debug_config = "--debug-configuration" in sys.argv
+ legacy_ignore_config = "--ignore_config" in sys.argv
+ out_xml = any(re.match("^--out-xml=(.*)$", a) for a in sys.argv)
+
+ engine = Engine()
+
+ global_build_dir = option.get("build-dir")
+ manager = Manager(engine, global_build_dir)
+
+ if "--version" in sys.argv:
+
+ version.report()
+ return
+
+ # This module defines types and generator and what not,
+ # and depends on manager's existence
+ import b2.tools.builtin
- bjam_targets = []
+ b2.tools.common.init(manager)
- # Given a target id, try to find and return corresponding target.
- # This is only invoked when there's no Jamfile in "."
- # This code somewhat duplicates code in project-target.find but we can't reuse
- # that code without project-targets instance.
- def find_target (target_id):
- split = target_id.split("//")
- pm = None
- if len(split) > 1:
- pm = projects.find(split[0], ".")
+ load_configuration_files()
+
+ extra_properties = []
+ # Note that this causes --toolset options to be ignored if --ignore-config
+ # is specified.
+ if not legacy_ignore_config:
+ extra_properties = process_explicit_toolset_requests()
+
+ # We always load project in "." so that 'use-project' directives have any
+ # chance of being seen. Otherwise, we would not be able to refer to
+ # subprojects using target ids.
+ current_project = None
+ projects = get_manager().projects()
+ if projects.find(".", "."):
+ current_project = projects.target(projects.load("."))
+
+ # In case there are no toolsets currently defined makes the build run using
+ # the default toolset.
+ if not legacy_ignore_config and not feature.values("toolset"):
+
+ dt = default_toolset
+ dtv = None
+ if default_toolset:
+ dtv = default_toolset_version
else:
- pm = projects.find(target_id, ".")
+ dt = "gcc"
+ if os.name == 'nt':
+ dt = "msvc"
+ # FIXME:
+ #else if [ os.name ] = MACOSX
+ #{
+ # default-toolset = darwin ;
+ #}
+
+ print "warning: No toolsets are configured."
+ print "warning: Configuring default toolset '%s'." % dt
+ print "warning: If the default is wrong, your build may not work correctly."
+ print "warning: Use the \"toolset=xxxxx\" option to override our guess."
+ print "warning: For more configuration options, please consult"
+ print "warning: http://boost.org/boost-build2/doc/html/bbv2/advanced/configuration.html"
- result = None
- if pm:
- result = projects.target(pm)
+ toolset.using(dt, dtv)
- if len(split) > 1:
- result = result.find(split[1])
+ # Parse command line for targets and properties. Note that this requires
+ # that all project files already be loaded.
+ (target_ids, properties) = build_request.from_command_line(sys.argv[1:] + extra_properties)
+
+ # Expand properties specified on the command line into multiple property
+ # sets consisting of all legal property combinations. Each expanded property
+ # set will be used for a single build run. E.g. if multiple toolsets are
+ # specified then requested targets will be built with each of them.
+ if properties:
+ expanded = build_request.expand_no_defaults(properties)
+ else:
+ expanded = [property_set.empty()]
+ # Check that we actually found something to build.
if not current_project and not target_ids:
- print "error: no Jamfile in current directory found, and no target references specified."
- sys.exit(1)
+ get_manager().errors()("no Jamfile in current directory found, and no target references specified.")
+ # FIXME:
+ # EXIT
+
+ # Flags indicating that this build system run has been started in order to
+ # clean existing instead of create new targets. Note that these are not the
+ # final flag values as they may get changed later on due to some special
+ # targets being specified on the command line.
+ clean = "--clean" in sys.argv
+ cleanall = "--clean-all" in sys.argv
+
+ # List of explicitly requested files to build. Any target references read
+ # from the command line parameter not recognized as one of the targets
+ # defined in the loaded Jamfiles will be interpreted as an explicitly
+ # requested file to build. If any such files are explicitly requested then
+ # only those files and the targets they depend on will be built and they
+ # will be searched for among targets that would have been built had there
+ # been no explicitly requested files.
+ explicitly_requested_files = []
+ # List of Boost Build meta-targets, virtual-targets and actual Jam targets
+ # constructed in this build system run.
+ targets = []
+ virtual_targets = []
+ actual_targets = []
+
+ # Process each target specified on the command-line and convert it into
+ # internal Boost Build target objects. Detect special clean target. If no
+ # main Boost Build targets were explictly requested use the current project
+ # as the target.
for id in target_ids:
if id == "clean":
clean = 1
@@ -332,7 +572,25 @@
if not targets:
targets = [projects.target(projects.module_name("."))]
+
+ # FIXME: put this BACK.
+ ## if [ option.get dump-generators : : true ]
+ ## {
+ ## generators.dump ;
+ ## }
+
+ ## # We wish to put config.log in the build directory corresponding
+ ## # to Jamroot, so that the location does not differ depending on
+ ## # directory where we do build. The amount of indirection necessary
+ ## # here is scary.
+ ## local first-project = [ $(targets[0]).project ] ;
+ ## local first-project-root-location = [ $(first-project).get project-root ] ;
+ ## local first-project-root-module = [ project.load $(first-project-root-location) ] ;
+ ## local first-project-root = [ project.target $(first-project-root-module) ] ;
+ ## local first-build-build-dir = [ $(first-project-root).build-dir ] ;
+ ## configure.set-log-file $(first-build-build-dir)/config.log ;
+
virtual_targets = []
# Virtual targets obtained when building main targets references on
@@ -344,6 +602,11 @@
# so we need to record which targets are produced.
results_of_main_targets = []
+
+ # Now that we have a set of targets to build and a set of property sets to
+ # build the targets with, we can start the main build process by using each
+ # property set to generate virtual targets from all of our listed targets
+ # and any of their dependants.
for p in expanded:
manager.set_command_line_free_features(property_set.create(p.free()))
@@ -358,78 +621,242 @@
except Exception:
raise
- # The cleaning is tricky. Say, if
- # user says:
- #
- # bjam --clean foo
- #
- # where 'foo' is a directory, then we want to clean targets
- # which are in 'foo' or in any children Jamfiles, but not in any
- # unrelated Jamfiles. So, we collect the list of project under which
- # cleaning is allowed.
- #
- projects_to_clean = []
- targets_to_clean = []
- if clean or clean_all:
- for t in targets:
- if isinstance(t, ProjectTarget):
- projects_to_clean.append(t.project_module())
-
- for t in results_of_main_targets:
- # Don't include roots or sources.
- targets_to_clean += b2.build.virtual_target.traverse(t)
-
- targets_to_clean = unique(targets_to_clean)
-
- is_child_cache_ = {}
-
- # Returns 'true' if 'project' is a child of 'current-project',
- # possibly indirect, or is equal to 'project'.
- # Returns 'false' otherwise.
- def is_child (project):
-
- r = is_child_cache_.get(project, None)
- if not r:
- if project in projects_to_clean:
- r = 1
- else:
- parent = manager.projects().attribute(project, "parent-module")
- if parent and parent != "user-config":
- r = is_child(parent)
- else:
- r = 0
+ # Convert collected virtual targets into actual raw Jam targets.
+ for t in virtual_targets:
+ actual_targets.append(t.actualize())
- is_child_cache_[project] = r
- return r
+ # FIXME: restore
+## # If XML data output has been requested prepare additional rules and targets
+## # so we can hook into Jam to collect build data while its building and have
+## # it trigger the final XML report generation after all the planned targets
+## # have been built.
+## if $(.out-xml)
+## {
+## # Get a qualified virtual target name.
+## rule full-target-name ( target )
+## {
+## local name = [ $(target).name ] ;
+## local project = [ $(target).project ] ;
+## local project-path = [ $(project).get location ] ;
+## return $(project-path)//$(name) ;
+## }
- actual_targets = []
- for t in virtual_targets:
- actual_targets.append(t.actualize())
+## # Generate an XML file containing build statistics for each constituent.
+## #
+## rule out-xml ( xml-file : constituents * )
+## {
+## # Prepare valid XML header and footer with some basic info.
+## local nl = "
+## " ;
+## local jam = [ version.jam ] ;
+## local os = [ modules.peek : OS OSPLAT JAMUNAME ] "" ;
+## local timestamp = [ modules.peek : JAMDATE ] ;
+## local cwd = [ PWD ] ;
+## local command = $(.sys.argv) ;
+## local bb-version = [ version.boost-build ] ;
+## .header on $(xml-file) =
+## "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
+## "$(nl)<build format=\"1.0\" version=\"$(bb-version)\">"
+## "$(nl) <jam version=\"$(jam:J=.)\" />"
+## "$(nl) <os name=\"$(os[1])\" platform=\"$(os[2])\"><![CDATA[$(os[3-]:J= )]]></os>"
+## "$(nl) <timestamp><![CDATA[$(timestamp)]]></timestamp>"
+## "$(nl) <directory><![CDATA[$(cwd)]]></directory>"
+## "$(nl) <command><![CDATA[\"$(command:J=\" \")\"]]></command>"
+## ;
+## .footer on $(xml-file) =
+## "$(nl)</build>" ;
+
+## # Generate the target dependency graph.
+## .contents on $(xml-file) +=
+## "$(nl) <targets>" ;
+## for local t in [ virtual-target.all-targets ]
+## {
+## local action = [ $(t).action ] ;
+## if $(action)
+## # If a target has no action, it has no dependencies.
+## {
+## local name = [ full-target-name $(t) ] ;
+## local sources = [ $(action).sources ] ;
+## local dependencies ;
+## for local s in $(sources)
+## {
+## dependencies += [ full-target-name $(s) ] ;
+## }
+
+## local path = [ $(t).path ] ;
+## local jam-target = [ $(t).actual-name ] ;
+
+## .contents on $(xml-file) +=
+## "$(nl) <target>"
+## "$(nl) <name><![CDATA[$(name)]]></name>"
+## "$(nl) <dependencies>"
+## "$(nl) <dependency><![CDATA[$(dependencies)]]></dependency>"
+## "$(nl) </dependencies>"
+## "$(nl) <path><![CDATA[$(path)]]></path>"
+## "$(nl) <jam-target><![CDATA[$(jam-target)]]></jam-target>"
+## "$(nl) </target>"
+## ;
+## }
+## }
+## .contents on $(xml-file) +=
+## "$(nl) </targets>" ;
+## # Build $(xml-file) after $(constituents). Do so even if a
+## # constituent action fails and regenerate the xml on every bjam run.
+## INCLUDES $(xml-file) : $(constituents) ;
+## ALWAYS $(xml-file) ;
+## __ACTION_RULE__ on $(xml-file) = build-system.out-xml.generate-action ;
+## out-xml.generate $(xml-file) ;
+## }
- bjam.call("NOTFILE", "all")
- bjam.call("DEPENDS", "all", actual_targets)
+## # The actual build actions are here; if we did this work in the actions
+## # clause we would have to form a valid command line containing the
+## # result of @(...) below (the name of the XML file).
+## #
+## rule out-xml.generate-action ( args * : xml-file
+## : command status start end user system : output ? )
+## {
+## local contents =
+## [ on $(xml-file) return $(.header) $(.contents) $(.footer) ] ;
+## local f = @($(xml-file):E=$(contents)) ;
+## }
- if bjam_targets:
- bjam.call("UPDATE", ["<e>%s" % x for x in bjam_targets])
- elif clean_all:
- bjam.call("UPDATE", "clean-all")
- elif clean:
- to_clean = []
- for t in manager.virtual_targets().all_targets():
- p = t.project()
+## # Nothing to do here; the *real* actions happen in
+## # out-xml.generate-action.
+## actions quietly out-xml.generate { }
+
+## # Define the out-xml file target, which depends on all the targets so
+## # that it runs the collection after the targets have run.
+## out-xml $(.out-xml) : $(actual-targets) ;
+
+## # Set up a global __ACTION_RULE__ that records all the available
+## # statistics about each actual target in a variable "on" the --out-xml
+## # target.
+## #
+## rule out-xml.collect ( xml-file : target : command status start end user
+## system : output ? )
+## {
+## local nl = "
+## " ;
+## # Open the action with some basic info.
+## .contents on $(xml-file) +=
+## "$(nl) <action status=\"$(status)\" start=\"$(start)\" end=\"$(end)\" user=\"$(user)\" system=\"$(system)\">" ;
+
+## # If we have an action object we can print out more detailed info.
+## local action = [ on $(target) return $(.action) ] ;
+## if $(action)
+## {
+## local action-name = [ $(action).action-name ] ;
+## local action-sources = [ $(action).sources ] ;
+## local action-props = [ $(action).properties ] ;
+
+## # The qualified name of the action which we created the target.
+## .contents on $(xml-file) +=
+## "$(nl) <name><![CDATA[$(action-name)]]></name>" ;
+
+## # The sources that made up the target.
+## .contents on $(xml-file) +=
+## "$(nl) <sources>" ;
+## for local source in $(action-sources)
+## {
+## local source-actual = [ $(source).actual-name ] ;
+## .contents on $(xml-file) +=
+## "$(nl) <source><![CDATA[$(source-actual)]]></source>" ;
+## }
+## .contents on $(xml-file) +=
+## "$(nl) </sources>" ;
+
+## # The properties that define the conditions under which the
+## # target was built.
+## .contents on $(xml-file) +=
+## "$(nl) <properties>" ;
+## for local prop in [ $(action-props).raw ]
+## {
+## local prop-name = [ MATCH ^<(.*)>$ : $(prop:G) ] ;
+## .contents on $(xml-file) +=
+## "$(nl) <property name=\"$(prop-name)\"><![CDATA[$(prop:G=)]]></property>" ;
+## }
+## .contents on $(xml-file) +=
+## "$(nl) </properties>" ;
+## }
- # Remove only derived targets.
- if t.action() and \
- (t in targets_to_clean or is_child(p.project_module())):
- to_clean.append(t)
+## local locate = [ on $(target) return $(LOCATE) ] ;
+## locate ?= "" ;
+## .contents on $(xml-file) +=
+## "$(nl) <jam-target><![CDATA[$(target)]]></jam-target>"
+## "$(nl) <path><![CDATA[$(target:G=:R=$(locate))]]></path>"
+## "$(nl) <command><![CDATA[$(command)]]></command>"
+## "$(nl) <output><![CDATA[$(output)]]></output>" ;
+## .contents on $(xml-file) +=
+## "$(nl) </action>" ;
+## }
+
+## # When no __ACTION_RULE__ is set "on" a target, the search falls back to
+## # the global module.
+## module
+## {
+## __ACTION_RULE__ = build-system.out-xml.collect
+## [ modules.peek build-system : .out-xml ] ;
+## }
+
+## IMPORT
+## build-system :
+## out-xml.collect
+## out-xml.generate-action
+## : :
+## build-system.out-xml.collect
+## build-system.out-xml.generate-action
+## ;
+## }
- to_clean_actual = [t.actualize() for t in to_clean]
- manager.engine().set_update_action('common.Clean', 'clean',
- to_clean_actual, None)
+ j = option.get("jobs")
+ if j:
+ bjam.call("set-variable", PARALLELISM, j)
+
+ k = option.get("keep-going", "true", "true")
+ if k in ["on", "yes", "true"]:
+ bjam.call("set-variable", "KEEP_GOING", "1")
+ elif k in ["off", "no", "false"]:
+ bjam.call("set-variable", "KEEP_GOING", "0")
+ else:
+ print "error: Invalid value for the --keep-going option"
+ sys.exit()
+
+ # The 'all' pseudo target is not strictly needed expect in the case when we
+ # use it below but people often assume they always have this target
+ # available and do not declare it themselves before use which may cause
+ # build failures with an error message about not being able to build the
+ # 'all' target.
+ bjam.call("NOTFILE", "all")
+ # And now that all the actual raw Jam targets and all the dependencies
+ # between them have been prepared all that is left is to tell Jam to update
+ # those targets.
+ if explicitly_requested_files:
+ # Note that this case can not be joined with the regular one when only
+ # exact Boost Build targets are requested as here we do not build those
+ # requested targets but only use them to construct the dependency tree
+ # needed to build the explicitly requested files.
+ # FIXME: add $(.out-xml)
+ bjam.call("UPDATE", ["<e>%s" % x for x in explicitly_requested_files])
+ elif cleanall:
+ bjam.call("UPDATE", "clean-all")
+ elif clean:
+ manager.engine().set_update_action("common.Clean", "clean",
+ actual_clean_targets(targets), None)
bjam.call("UPDATE", "clean")
-
else:
- bjam.call("UPDATE", "all")
+ # FIXME:
+ #configure.print-configure-checks-summary ;
+
+ if pre_build_hook:
+ pre_build_hook()
+
+ bjam.call("DEPENDS", "all", actual_targets)
+ ok = bjam.call("UPDATE_NOW", "all") # FIXME: add out-xml
+ if post_build_hook:
+ post_build_hook(ok)
+ # Prevent automatic update of the 'all' target, now that
+ # we have explicitly updated what we wanted.
+ bjam.call("UPDATE")
Modified: trunk/tools/build/v2/test/BoostBuild.py
==============================================================================
--- trunk/tools/build/v2/test/BoostBuild.py (original)
+++ trunk/tools/build/v2/test/BoostBuild.py 2010-07-26 04:28:12 EDT (Mon, 26 Jul 2010)
@@ -668,6 +668,8 @@
self.ignore("bin/config.log")
+ self.ignore("*.pyc")
+
if not self.unexpected_difference.empty():
annotation('failure', 'Unexpected changes found')
output = StringIO.StringIO()
Modified: trunk/tools/build/v2/test/dll_path.py
==============================================================================
--- trunk/tools/build/v2/test/dll_path.py (original)
+++ trunk/tools/build/v2/test/dll_path.py 2010-07-26 04:28:12 EDT (Mon, 26 Jul 2010)
@@ -29,10 +29,10 @@
""")
t.write("jamroot.jam", """
-using dll-paths ;
+using dll_paths ;
""")
-t.write("dll-paths.jam", """
+t.write("dll_paths.jam", """
import type ;
import generators ;
import feature ;
Modified: trunk/tools/build/v2/test/explicit.py
==============================================================================
--- trunk/tools/build/v2/test/explicit.py (original)
+++ trunk/tools/build/v2/test/explicit.py 2010-07-26 04:28:12 EDT (Mon, 26 Jul 2010)
@@ -8,9 +8,7 @@
t = BoostBuild.Tester()
-t.write("jamroot.jam", "")
-
-t.write("jamfile.jam", """
+t.write("jamroot.jam", """
exe hello : hello.cpp ;
exe hello2 : hello.cpp ;
explicit hello2 ;
Added: trunk/tools/build/v2/util/option.py
==============================================================================
--- (empty file)
+++ trunk/tools/build/v2/util/option.py 2010-07-26 04:28:12 EDT (Mon, 26 Jul 2010)
@@ -0,0 +1,34 @@
+# Copyright (c) 2005-2010 Vladimir Prus.
+#
+# Use, modification and distribution is subject to the Boost Software
+# License Version 1.0. (See accompanying file LICENSE_1_0.txt or
+# http://www.boost.org/LICENSE_1_0.txt)
+
+import sys
+import b2.util.regex
+
+options = {}
+
+# Set a value for a named option, to be used when not overridden on the command
+# line.
+def set(name, value=None):
+
+ global options
+
+ options[name] = value
+
+def get(name, default_value=None, implied_value=None):
+
+ global options
+
+ matches = b2.util.regex.transform(sys.argv, "--$(name)=(.*)")
+ if matches:
+ return matches[-1]
+ else:
+ m = b2.util.regex.transform(sys.argv, "--$(name)")
+ if m and implied_value:
+ return implied_value
+ elif options.has_key(name):
+ return options[name]
+ else:
+ return default_value
Modified: trunk/tools/build/v2/util/path.py
==============================================================================
--- trunk/tools/build/v2/util/path.py (original)
+++ trunk/tools/build/v2/util/path.py 2010-07-26 04:28:12 EDT (Mon, 26 Jul 2010)
@@ -303,70 +303,47 @@
result.extend (glob.glob (p))
return result
-# #
-# # Returns true is the specified file exists.
-# #
-# rule exists ( file )
-# {
-# return [ path.glob $(file:D) : $(file:D=) ] ;
-# }
-# NATIVE_RULE path : exists ;
-#
-#
-#
-# #
-# # Find out the absolute name of path and returns the list of all the parents,
-# # starting with the immediate one. Parents are returned as relative names.
-# # If 'upper_limit' is specified, directories above it will be pruned.
-# #
-# rule all-parents ( path : upper_limit ? : cwd ? )
-# {
-# cwd ?= [ pwd ] ;
-# local path_ele = [ regex.split [ root $(path) $(cwd) ] "/" ] ;
-#
-# if ! $(upper_limit) {
-# upper_limit = / ;
-# }
-# local upper_ele = [ regex.split [ root $(upper_limit) $(cwd) ] "/" ] ;
-#
-# # Leave only elements in 'path_ele' below 'upper_ele'
-# while $(path_ele) && $(upper_ele[1]) = $(path_ele[1]) {
-# upper_ele = $(upper_ele[2-]) ;
-# path_ele = $(path_ele[2-]) ;
-# }
-#
-# # All upper elements removed ?
-# if ! $(upper_ele) {
-# # Create the relative paths to parents, number of elements in 'path_ele'
-# local result ;
-# for local i in $(path_ele) {
-# path = [ parent $(path) ] ;
-# result += $(path) ;
-# }
-# return $(result) ;
-# }
-# else {
-# error "$(upper_limit) is not prefix of $(path)" ;
-# }
-# }
-#
-#
-# #
-# # Search for 'pattern' in parent directories of 'dir', up till and including
-# # 'upper_limit', if it is specified, or till the filesystem root otherwise.
-# #
-# rule glob-in-parents ( dir : patterns + : upper-limit ? )
-# {
-# local result ;
-# local parent-dirs = [ all-parents $(dir) : $(upper-limit) ] ;
-#
-# while $(parent-dirs) && ! $(result)
-# {
-# result = [ glob $(parent-dirs[1]) : $(patterns) ] ;
-# parent-dirs = $(parent-dirs[2-]) ;
-# }
-# return $(result) ;
-# }
+#
+# Find out the absolute name of path and returns the list of all the parents,
+# starting with the immediate one. Parents are returned as relative names.
+# If 'upper_limit' is specified, directories above it will be pruned.
+#
+def all_parents(path, upper_limit=None, cwd=None):
+
+ if not cwd:
+ cwd = os.getcwd()
+
+ path_abs = os.path.join(cwd, path)
+
+ if upper_limit:
+ upper_limit = os.path.join(cwd, upper_limit)
+
+ result = []
+ while path_abs and path_abs != upper_limit:
+ (head, tail) = os.path.split(path)
+ path = os.path.join(path, "..")
+ result.append(path)
+ path_abs = head
+
+ if upper_limit and path_abs != upper_limit:
+ raise BaseException("'%s' is not a prefix of '%s'" % (upper_limit, path))
+
+ return result
+
+# Search for 'pattern' in parent directories of 'dir', up till and including
+# 'upper_limit', if it is specified, or till the filesystem root otherwise.
+#
+def glob_in_parents(dir, patterns, upper_limit=None):
+
+ result = []
+ parent_dirs = all_parents(dir, upper_limit)
+
+ for p in parent_dirs:
+ result = glob(p, patterns)
+ if result: break
+
+ return result
+
#
# #
# # Assuming 'child' is a subdirectory of 'parent', return the relative