| # $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_tagged(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) |
