diff options
Diffstat (limited to 'tools/build/src/contrib/boost.py')
| -rw-r--r-- | tools/build/src/contrib/boost.py | 279 |
1 files changed, 279 insertions, 0 deletions
diff --git a/tools/build/src/contrib/boost.py b/tools/build/src/contrib/boost.py new file mode 100644 index 0000000000..e0bbcf34de --- /dev/null +++ b/tools/build/src/contrib/boost.py @@ -0,0 +1,279 @@ +# $Id: boost.jam 62249 2010-05-26 19:05:19Z steven_watanabe $ +# Copyright 2008 Roland Schwarz +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) + +# Boost library support module. +# +# This module allows to use the boost library from boost-build projects. +# The location of a boost source tree or the path to a pre-built +# version of the library can be configured from either site-config.jam +# or user-config.jam. If no location is configured the module looks for +# a BOOST_ROOT environment variable, which should point to a boost source +# tree. As a last resort it tries to use pre-built libraries from the standard +# search path of the compiler. +# +# If the location to a source tree is known, the module can be configured +# from the *-config.jam files: +# +# using boost : 1.35 : <root>/path-to-boost-root ; +# +# If the location to a pre-built version is known: +# +# using boost : 1.34 +# : <include>/usr/local/include/boost_1_34 +# <library>/usr/local/lib +# ; +# +# It is legal to configure more than one boost library version in the config +# files. The version identifier is used to disambiguate between them. +# The first configured version becomes the default. +# +# To use a boost library you need to put a 'use' statement into your +# Jamfile: +# +# import boost ; +# +# boost.use-project 1.35 ; +# +# If you don't care about a specific version you just can omit the version +# part, in which case the default is picked up: +# +# boost.use-project ; +# +# The library can be referenced with the project identifier '/boost'. To +# reference the program_options you would specify: +# +# exe myexe : mysrc.cpp : <library>/boost//program_options ; +# +# Note that the requirements are automatically transformed into suitable +# tags to find the correct pre-built library. +# + +import re + +import bjam + +from b2.build import alias, property, property_set, feature +from b2.manager import get_manager +from b2.tools import builtin, common +from b2.util import bjam_signature, regex + + +# TODO: This is currently necessary in Python Port, but was not in Jam. +feature.feature('layout', ['system', 'versioned', 'tag'], ['optional']) +feature.feature('root', [], ['optional', 'free']) +feature.feature('build-id', [], ['optional', 'free']) + +__initialized = None +__boost_auto_config = property_set.create([property.Property('layout', 'system')]) +__boost_configured = {} +__boost_default = None +__build_id = None + +__debug = None + +def debug(): + global __debug + if __debug is None: + __debug = "--debug-configuration" in bjam.variable("ARGV") + return __debug + + +# Configuration of the boost library to use. +# +# This can either be a boost source tree or +# pre-built libraries. The 'version' parameter must be a valid boost +# version number, e.g. 1.35, if specifying a pre-built version with +# versioned layout. It may be a symbolic name, e.g. 'trunk' if specifying +# a source tree. The options are specified as named parameters (like +# properties). The following paramters are available: +# +# <root>/path-to-boost-root: Specify a source tree. +# +# <include>/path-to-include: The include directory to search. +# +# <library>/path-to-library: The library directory to search. +# +# <layout>system or <layout>versioned. +# +# <build-id>my_build_id: The custom build id to use. +# +def init(version, options = None): + assert(isinstance(version,list)) + assert(len(version)==1) + version = version[0] + if version in __boost_configured: + get_manager().errors()("Boost {} already configured.".format(version)); + else: + global __boost_default + if debug(): + if not __boost_default: + print "notice: configuring default boost library {}".format(version) + print "notice: configuring boost library {}".format(version) + + if not __boost_default: + __boost_default = version + properties = [] + for option in options: + properties.append(property.create_from_string(option)) + __boost_configured[ version ] = property_set.PropertySet(properties) + +projects = get_manager().projects() +rules = projects.project_rules() + + +# Use a certain version of the library. +# +# The use-project rule causes the module to define a boost project of +# searchable pre-built boost libraries, or references a source tree +# of the boost library. If the 'version' parameter is omitted either +# the configured default (first in config files) is used or an auto +# configuration will be attempted. +# +@bjam_signature(([ "version", "?" ], )) +def use_project(version = None): + projects.push_current( projects.current() ) + if not version: + version = __boost_default + if not version: + version = "auto_config" + + global __initialized + if __initialized: + if __initialized != version: + get_manager().errors()('Attempt to use {} with different parameters'.format('boost')) + else: + if version in __boost_configured: + opts = __boost_configured[ version ] + root = opts.get('<root>' ) + inc = opts.get('<include>') + lib = opts.get('<library>') + + if debug(): + print "notice: using boost library {} {}".format( version, opt.raw() ) + + global __layout + global __version_tag + __layout = opts.get('<layout>') + if not __layout: + __layout = 'versioned' + __build_id = opts.get('<build-id>') + __version_tag = re.sub("[*\\/:.\"\' ]", "_", version) + __initialized = version + + if ( root and inc ) or \ + ( root and lib ) or \ + ( lib and not inc ) or \ + ( not lib and inc ): + get_manager().errors()("Ambiguous parameters, use either <root> or <inlude> with <library>.") + elif not root and not inc: + root = bjam.variable("BOOST_ROOT") + + module = projects.current().project_module() + + if root: + bjam.call('call-in-module', module, 'use-project', ['boost', root]) + else: + projects.initialize(__name__) + if version == '0.0.1': + boost_0_0_1( inc, lib ) + else: + boost_std( inc, lib ) + else: + get_manager().errors()("Reference to unconfigured boost version.") + projects.pop_current() + + +rules.add_rule( 'boost.use-project', use_project ) + +def boost_std(inc = None, lib = None): + # The default definitions for pre-built libraries. + rules.project( + ['boost'], + ['usage-requirements'] + ['<include>{}'.format(i) for i in inc] + ['<define>BOOST_ALL_NO_LIB'], + ['requirements'] + ['<search>{}'.format(l) for l in lib]) + + # TODO: There should be a better way to add a Python function into a + # project requirements property set. + tag_prop_set = property_set.create([property.Property('<tag>', tag_std)]) + attributes = projects.attributes(projects.current().project_module()) + attributes.requirements = attributes.requirements.refine(tag_prop_set) + + alias('headers') + + def boost_lib(lib_name, dyn_link_macro): + if (isinstance(lib_name,str)): + lib_name = [lib_name] + builtin.lib(lib_name, usage_requirements=['<link>shared:<define>{}'.format(dyn_link_macro)]) + + boost_lib('date_time' , 'BOOST_DATE_TIME_DYN_LINK' ) + boost_lib('filesystem' , 'BOOST_FILE_SYSTEM_DYN_LINK' ) + boost_lib('graph' , 'BOOST_GRAPH_DYN_LINK' ) + boost_lib('graph_parallel' , 'BOOST_GRAPH_DYN_LINK' ) + boost_lib('iostreams' , 'BOOST_IOSTREAMS_DYN_LINK' ) + boost_lib('locale' , 'BOOST_LOG_DYN_LINK' ) + boost_lib('log' , 'BOOST_LOG_DYN_LINK' ) + boost_lib('log_setup' , 'BOOST_LOG_DYN_LINK' ) + boost_lib('math_tr1' , 'BOOST_MATH_TR1_DYN_LINK' ) + boost_lib('math_tr1f' , 'BOOST_MATH_TR1_DYN_LINK' ) + boost_lib('math_tr1l' , 'BOOST_MATH_TR1_DYN_LINK' ) + boost_lib('math_c99' , 'BOOST_MATH_TR1_DYN_LINK' ) + boost_lib('math_c99f' , 'BOOST_MATH_TR1_DYN_LINK' ) + boost_lib('math_c99l' , 'BOOST_MATH_TR1_DYN_LINK' ) + boost_lib('mpi' , 'BOOST_MPI_DYN_LINK' ) + boost_lib('program_options' , 'BOOST_PROGRAM_OPTIONS_DYN_LINK') + boost_lib('python' , 'BOOST_PYTHON_DYN_LINK' ) + boost_lib('python3' , 'BOOST_PYTHON_DYN_LINK' ) + boost_lib('random' , 'BOOST_RANDOM_DYN_LINK' ) + boost_lib('regex' , 'BOOST_REGEX_DYN_LINK' ) + boost_lib('serialization' , 'BOOST_SERIALIZATION_DYN_LINK' ) + boost_lib('wserialization' , 'BOOST_SERIALIZATION_DYN_LINK' ) + boost_lib('signals' , 'BOOST_SIGNALS_DYN_LINK' ) + boost_lib('system' , 'BOOST_SYSTEM_DYN_LINK' ) + boost_lib('unit_test_framework' , 'BOOST_TEST_DYN_LINK' ) + boost_lib('prg_exec_monitor' , 'BOOST_TEST_DYN_LINK' ) + boost_lib('test_exec_monitor' , 'BOOST_TEST_DYN_LINK' ) + boost_lib('thread' , 'BOOST_THREAD_DYN_DLL' ) + boost_lib('wave' , 'BOOST_WAVE_DYN_LINK' ) + +def boost_0_0_1( inc, lib ): + print "You are trying to use an example placeholder for boost libs." ; + # Copy this template to another place (in the file boost.jam) + # and define a project and libraries modelled after the + # boost_std rule. Please note that it is also possible to have + # a per version taging rule in case they are different between + # versions. + +def tag_std(name, type, prop_set): + name = 'boost_' + name + if 'static' in prop_set.get('<link>') and 'windows' in prop_set.get('<target-os>'): + name = 'lib' + name + result = None + + if __layout == 'system': + versionRe = re.search('^([0-9]+)_([0-9]+)', __version_tag) + if versionRe and versionRe.group(1) == '1' and int(versionRe.group(2)) < 39: + result = tag_tagged(name, type, prop_set) + else: + result = tag_system(name, type, prop_set) + elif __layout == 'tagged': + result = tag_tagged(name, type, prop_set) + elif __layout == 'versioned': + result = tag_versioned(name, type, prop_set) + else: + get_manager().errors()("Missing layout") + return result + +def tag_maybe(param): + return ['-{}'.format(param)] if param else [] + +def tag_system(name, type, prop_set): + return common.format_name(['<base>'] + tag_maybe(__build_id), name, type, prop_set) + +def tag_system(name, type, prop_set): + return common.format_name(['<base>', '<threading>', '<runtime>'] + tag_maybe(__build_id), name, type, prop_set) + +def tag_versioned(name, type, prop_set): + return common.format_name(['<base>', '<toolset>', '<threading>', '<runtime>'] + tag_maybe(__version_tag) + tag_maybe(__build_id), + name, type, prop_set) |