diff options
Diffstat (limited to 'src/boost/tools/build/src/build_system.py')
| -rw-r--r-- | src/boost/tools/build/src/build_system.py | 682 |
1 files changed, 682 insertions, 0 deletions
diff --git a/src/boost/tools/build/src/build_system.py b/src/boost/tools/build/src/build_system.py new file mode 100644 index 000000000..1702acf5a --- /dev/null +++ b/src/boost/tools/build/src/build_system.py @@ -0,0 +1,682 @@ +# Status: mostly ported. Missing is --out-xml support, 'configure' integration +# and some FIXME. +# Base revision: 64351 + +# Copyright 2003, 2005 Dave Abrahams +# Copyright 2006 Rene Rivera +# Copyright 2003, 2004, 2005, 2006, 2007 Vladimir Prus +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE.txt or copy at +# https://www.bfgroup.xyz/b2/LICENSE.txt) +import os +import sys +import re + +import bjam + +# set this early on since some of the following modules +# require looking at the sys.argv +sys.argv = bjam.variable("ARGV") + + +from b2.build.engine import Engine +from b2.manager import Manager +from b2.util.path import glob +from b2.build import feature, property_set +import b2.build.virtual_target +from b2.build.targets import ProjectTarget +import b2.build.build_request +from b2.build.errors import ExceptionWithUserContext +import b2.tools.common +from b2.build.toolset import using + +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 + +################################################################################ +# +# Module global data. +# +################################################################################ + +# Flag indicating we should display additional debugging information related to +# locating and loading Boost Build configuration files. +debug_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 + + +pre_build_hook = [] + +def add_pre_build_hook(callable): + pre_build_hook.append(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): + + projects = get_manager().projects() + m = _target_id_split.match(target_id) + if m: + pm = projects.find(m.group(1), ".") + else: + pm = projects.find(target_id, ".") + + if pm: + result = projects.target(pm) + + if m: + result = result.find(m.group(2)) + + return result + +def initialize_config_module(module_name, location=None): + + get_manager().projects().initialize(module_name, location) + +# 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: Loading '%s' configuration file '%s' from '%s'." \ + % (module_name, filename, where) + + # 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 the --ignore-site-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 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 + + 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: + 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("~")] + bjam.variable("BOOST_BUILD_PATH") + site_path = ["/etc"] + user_path + if os.name in ["nt"]: + site_path = [os.getenv("SystemRoot")] + user_path + + if debug_config and not test_config and ignore_site_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: + load_config('site-config', 'site-config.jam', site_path) + + initialize_config_module('user-config') + if not test_config: + + # Here, user_config has value of None if nothing is explicitly + # specified, and value of '' if user explicitly does not want + # to load any user config. + user_config = None + for a in sys.argv: + m = re.match("--user-config=(.*)$", a) + if m: + user_config = m.group(1) + break + + if user_config is None: + 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 user_config is None: + user_config = "user-config.jam" + + if user_config: + 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) + else: + if 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 alongside the + # Jamroot file. However: + # - We need to load project-config.jam before Jamroot + # - We probably need to load project-config.jam even if there is 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', os.path.dirname(file[0])) + load_config('project-config', "project-config.jam", [os.path.dirname(file[0])], True) + + get_manager().projects().end_load() + + +# 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 + if version is not None: + using(toolset, version) + else: + using(toolset) + + 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(): + + # FIXME: document this option. + if "--profiling" in sys.argv: + import cProfile + r = cProfile.runctx('main_real()', globals(), locals(), "stones.prof") + + import pstats + stats = pstats.Stats("stones.prof") + stats.strip_dirs() + stats.sort_stats('time', 'calls') + stats.print_callers(20) + return r + else: + try: + return main_real() + except ExceptionWithUserContext, e: + e.report() + +def main_real(): + + global debug_config, out_xml + + debug_config = "--debug-configuration" 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) + + import b2.build.configure as configure + + if "--version" in sys.argv: + from b2.build import version + 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) + + load_configuration_files() + + # Load explicitly specified toolset modules. + extra_properties = process_explicit_toolset_requests() + + # Load the actual project build script modules. We always load the project + # in the current folder so '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(".")) + + # Load the default toolset module if no other has already been specified. + if 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: https://www.bfgroup.xyz/b2/manual/release/index.html#bbv2.overview.configuration" + + using(dt, dtv) + + # 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) + + # Check that we actually found something to build. + if not current_project and not target_ids: + 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 = [] + + explicitly_requested_files = [] + + # 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 explicitly requested use the current project + # as the target. + for id in target_ids: + if id == "clean": + clean = 1 + else: + t = None + if current_project: + t = current_project.find(id, no_error=1) + else: + t = find_target(id) + + if not t: + print "notice: could not find main target '%s'" % id + print "notice: assuming it's a name of file to create " ; + explicitly_requested_files.append(id) + else: + targets.append(t) + + 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. + first_project = targets[0].project() + first_project_root_location = first_project.get('project-root') + first_project_root_module = manager.projects().load(first_project_root_location) + first_project_root = manager.projects().target(first_project_root_module) + first_build_build_dir = first_project_root.build_dir() + configure.set_log_file(os.path.join(first_build_build_dir, "config.log")) + + virtual_targets = [] + + global results_of_main_targets + + # 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. + # The expansion is being performed as late as possible so that the feature + # validation is performed after all necessary modules (including project targets + # on the command line) have been loaded. + if properties: + expanded = [] + for p in properties: + expanded.extend(build_request.convert_command_line_element(p)) + + expanded = build_request.expand_no_defaults(expanded) + else: + expanded = [property_set.empty()] + + # 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())) + + for t in targets: + try: + g = t.generate(p) + if not isinstance(t, ProjectTarget): + results_of_main_targets.extend(g.targets()) + virtual_targets.extend(g.targets()) + except ExceptionWithUserContext, e: + e.report() + except Exception: + raise + + # Convert collected virtual targets into actual raw Jam targets. + for t in virtual_targets: + actual_targets.append(t.actualize()) + + 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)) + bjam.call("UPDATE", "clean") + else: + # FIXME: + #configure.print-configure-checks-summary ; + + if pre_build_hook: + for h in pre_build_hook: + h() + + 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") + + if manager.errors().count() == 0: + return ["ok"] + else: + return [] |