From 77ee1e6c565a8a71782f6b494bc1301226bc5bdd Mon Sep 17 00:00:00 2001 From: Vladimir Prus Date: Mon, 26 Jul 2010 08:28:12 +0000 Subject: [PATCH] Major update of top level 'build_system.py' module. [SVN r64351] --- v2/build/build_request.py | 6 +- v2/build/targets.py | 20 +- v2/build_system.py | 1025 ++++++++++++++++++++++++++----------- v2/test/BoostBuild.py | 2 + v2/test/dll_path.py | 4 +- v2/test/explicit.py | 4 +- v2/util/option.py | 34 ++ v2/util/path.py | 105 ++-- 8 files changed, 821 insertions(+), 379 deletions(-) create mode 100644 v2/util/option.py diff --git a/v2/build/build_request.py b/v2/build/build_request.py index ae85a3249..cc9f2400a 100644 --- a/v2/build/build_request.py +++ b/v2/build/build_request.py @@ -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 @@ def convert_command_line_element(e): 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__ ( ) diff --git a/v2/build/targets.py b/v2/build/targets.py index f85fe9816..d86f67a68 100644 --- a/v2/build/targets.py +++ b/v2/build/targets.py @@ -81,9 +81,11 @@ import property, project, virtual_target, property_set, feature, generators, too 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 @@ class ProjectTarget (AbstractTarget): 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 @@ class ProjectTarget (AbstractTarget): # 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 @@ class ProjectTarget (AbstractTarget): 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 @@ class MainTarget (AbstractTarget): 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 @@ class BasicTarget (AbstractTarget): # 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" diff --git a/v2/build_system.py b/v2/build_system.py index 0403d5b13..b5979f9a2 100644 --- a/v2/build_system.py +++ b/v2/build_system.py @@ -17,78 +17,418 @@ import b2.build.build_request 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) ; -#} +################################################################################ +# +# Module global data. +# +################################################################################ -# FIXME: +# Flag indicating we should display additional debugging information related to +# locating and loading Boost Build configuration files. +debug_config = False -def get_boolean_option(name): - match = "--" + name - if match in argv: - return 1 - else: - return 0 +# 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 +pre_build_hook = 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) +def set_pre_build_hook(callable): + pre_build_hook = callable + +post_build_hook = None + +def set_post_build_hook(callable): + post_build_hook = callable + +################################################################################ +# +# Local rules. +# +################################################################################ + +# Returns actual Jam targets to be used for executing a clean request. +# +def actual_clean_targets(targets): + + # 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: - return [os.environ['HOME']] + pm = project.find(target_id, ".") -ignore_config = 0 -debug_config = 0 + if pm: + result = project.target(pm) -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 m: + result = result.find(m.group(2)) - if not ignore_config: - found = glob(path, [basename + ".jam"]) - if found: - found = found[0] + return result + +def initialize_config_module(module_name): + + 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): + + if debug_config: + print "notice: Searching '%s' for '%s' configuration file '%s." \ + % (paths, module_name, filename) + + 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: searching '%s' for '%s.jam'" % (path, basename) - if found: - print "notice: loading %s.jam from %s" % (basename, found) + print "notice: Loading '%s' configuration file '%s' from '%s'." \ + % (module_name, filename, where) - manager.projects().load_standalone(basename, found) + # 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 + + 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 os.name in ["nt"]: + site_path = [os.getenv("SystemRoot")] + user_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 + + 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 explicitly_requested: + + user_config = os.path.abspath(user_config) + + 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) + + 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"]) + + if file: + initialize_config_module('project-config') + load_config('project-config', "project-config.jam", [os.path.dirname(file[0])], True) + + +# 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(): + + extra_properties = [] + + 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(',')] + + for t in option_toolsets + feature_toolsets: + + # Parse toolset-version/properties. + (toolset_version, toolset, version) = re.match("(([^-/]+)-?([^/]+)?)/?.*", t).groups() + + 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) + + else: + + if debug_config: + + print "notice: [cmdline-cfg] toolset '%s' already configured" % toolset_version + + # 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: + + if debug_config: + print "notice: [cmdline-cfg] adding toolset=%s) to the build request." % t ; + extra_properties += "toolset=%s" % t + + return extra_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 project in project_targets: + return True + else: + + 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(): - global argv - argv = bjam.variable("ARGV") + sys.argv = bjam.variable("ARGV") # FIXME: document this option. - if "--profiling" in argv: + if "--profiling" in sys.argv: import cProfile import pstats cProfile.runctx('main_real()', globals(), locals(), "stones.prof") @@ -102,217 +442,117 @@ def main(): def main_real(): - global ignore_config - global debug_config - - boost_build_path = bjam.variable("BOOST_BUILD_PATH") + 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 = get_string_option("build-dir") - debug_config = get_boolean_option("debug-configuration") + 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 + b2.tools.common.init(manager) - # 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] + load_configuration_files() - if test_config: - 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" + 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() - manager.projects().load_standalone("test-config", test_config) - - - ignore_config = test_config or get_boolean_option("ignore-config") - user_path = home_directories() + boost_build_path - - site_path = ["/etc"] + user_path - if bjam.variable("OS") in ["NT", "CYGWIN"]: - site_path = [os.environ("SystemRoot")] + user_path - - load_config(manager, "site-config", site_path) - - user_config_path = get_string_option("user-config") - if not user_config_path: - user_config_path = os.environ.get("BOOST_BUILD_USER_CONFIG") - - if user_config_path: - if debug_config: - print "Loading explicitly specifier user configuration file:" - print " %s" % user_config_path - - manager.projects().load_standalone("user-config", user_config_path) - - else: - load_config(manager, "user-config", user_path) - - -# 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 $(debug-config) -## { -## ECHO notice: [cmdline-cfg] Detected command-line request for -## $(toolset-version): toolset= \"$(toolset)\" "version= \""$(version)\" ; -## } - -## local known ; - -## # if the toolset isn't known, configure it now. -## if $(toolset) in [ feature.values ] -## { -## known = true ; -## } - -## if $(known) && $(version) -## && ! [ feature.is-subvalue toolset : $(toolset) : version : $(version) ] -## { -## known = ; -## } - -## 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 ; -## } -## } - -## # 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) ; -## } -## } -## } - - -# FIXME: -## if USER_MODULE in [ RULENAMES ] -## { -## USER_MODULE site-config user-config ; -## } - - 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) - - b2.tools.common.init(manager) - - # 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 + # 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 = manager.projects() + projects = get_manager().projects() if projects.find(".", "."): current_project = projects.target(projects.load(".")) - # FIXME: revive this logic, when loading of gcc works - if not feature.values("") 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." + # 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: + 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" - projects.project_rules().using([default_toolset]) + toolset.using(dt, dtv) - (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] + # 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 = b2.build.build_request.expand_no_defaults(properties) + expanded = build_request.expand_no_defaults(properties) else: expanded = [property_set.empty()] - targets = [] - - clean = get_boolean_option("clean") - clean_all = get_boolean_option("clean-all") - - - bjam_targets = [] - - # 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], ".") - else: - pm = projects.find(target_id, ".") - - result = None - if pm: - result = projects.target(pm) - - if len(split) > 1: - result = result.find(split[1]) - + # 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 @@ def main_real(): 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 @@ def main_real(): # 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 @@ def main_real(): 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 - - is_child_cache_[project] = r - - return r - - actual_targets = [] + # Convert collected virtual targets into actual raw Jam targets. for t in virtual_targets: actual_targets.append(t.actualize()) - bjam.call("NOTFILE", "all") - bjam.call("DEPENDS", "all", actual_targets) + # 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) ; +## } - if bjam_targets: - bjam.call("UPDATE", ["%s" % x for x in bjam_targets]) - elif clean_all: +## # 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) = +## "" +## "$(nl)" +## "$(nl) " +## "$(nl) " +## "$(nl) " +## "$(nl) " +## "$(nl) " +## ; +## .footer on $(xml-file) = +## "$(nl)" ; + +## # Generate the target dependency graph. +## .contents on $(xml-file) += +## "$(nl) " ; +## 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) " +## "$(nl) " +## "$(nl) " +## "$(nl) " +## "$(nl) " +## "$(nl) " +## "$(nl) " +## "$(nl) " +## ; +## } +## } +## .contents on $(xml-file) += +## "$(nl) " ; + +## # 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) ; +## } + +## # 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)) ; +## } + +## # 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) " ; + +## # 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) " ; + +## # The sources that made up the target. +## .contents on $(xml-file) += +## "$(nl) " ; +## for local source in $(action-sources) +## { +## local source-actual = [ $(source).actual-name ] ; +## .contents on $(xml-file) += +## "$(nl) " ; +## } +## .contents on $(xml-file) += +## "$(nl) " ; + +## # The properties that define the conditions under which the +## # target was built. +## .contents on $(xml-file) += +## "$(nl) " ; +## for local prop in [ $(action-props).raw ] +## { +## local prop-name = [ MATCH ^<(.*)>$ : $(prop:G) ] ; +## .contents on $(xml-file) += +## "$(nl) " ; +## } +## .contents on $(xml-file) += +## "$(nl) " ; +## } + +## local locate = [ on $(target) return $(LOCATE) ] ; +## locate ?= "" ; +## .contents on $(xml-file) += +## "$(nl) " +## "$(nl) " +## "$(nl) " +## "$(nl) " ; +## .contents on $(xml-file) += +## "$(nl) " ; +## } + +## # 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 +## ; +## } + + 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", ["%s" % x for x in explicitly_requested_files]) + elif cleanall: bjam.call("UPDATE", "clean-all") elif clean: - to_clean = [] - for t in manager.virtual_targets().all_targets(): - p = t.project() - - # Remove only derived targets. - if t.action() and \ - (t in targets_to_clean or is_child(p.project_module())): - to_clean.append(t) - - to_clean_actual = [t.actualize() for t in to_clean] - manager.engine().set_update_action('common.Clean', 'clean', - to_clean_actual, None) - + 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") diff --git a/v2/test/BoostBuild.py b/v2/test/BoostBuild.py index 79daafa07..6be72abed 100644 --- a/v2/test/BoostBuild.py +++ b/v2/test/BoostBuild.py @@ -668,6 +668,8 @@ class Tester(TestCmd.TestCmd): self.ignore("bin/config.log") + self.ignore("*.pyc") + if not self.unexpected_difference.empty(): annotation('failure', 'Unexpected changes found') output = StringIO.StringIO() diff --git a/v2/test/dll_path.py b/v2/test/dll_path.py index 4efc2019c..a02b2b04e 100644 --- a/v2/test/dll_path.py +++ b/v2/test/dll_path.py @@ -29,10 +29,10 @@ int main() {} """) 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 ; diff --git a/v2/test/explicit.py b/v2/test/explicit.py index 2665becf8..43137402b 100644 --- a/v2/test/explicit.py +++ b/v2/test/explicit.py @@ -8,9 +8,7 @@ import BoostBuild 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 ; diff --git a/v2/util/option.py b/v2/util/option.py new file mode 100644 index 000000000..1f253f1c4 --- /dev/null +++ b/v2/util/option.py @@ -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 diff --git a/v2/util/path.py b/v2/util/path.py index f5cbc63f3..dc02d2497 100644 --- a/v2/util/path.py +++ b/v2/util/path.py @@ -303,70 +303,47 @@ def glob (dirs, patterns): 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