|
|
Boost-Build : |
From: Roland Schwarz (roland.schwarz_at_[hidden])
Date: 2008-04-04 13:58:30
I just have finished a module for easier use of pre-built boost
libraries.
Other than in windows builds there is no auto-link
available with gcc. This makes it very tedious to specify boost
library names if multiple variants tagged for debug,release
static,shared or different compiler versions are installed.
My module allows to uniformly name the libraries from the
project Jamfiles while still being able to get the appropriately
tagged versions.
A typical use would be to specify in user-config.jam
import boost ;
# Configure the pre-built 1.35 version as the default.
boost.config 1.35
: <include>/home/roland/include/boost-1_35
<library>/home/roland/lib
;
# Configure the version with the symbolic name 'trunk' to use a specific
# source tree.
boost.config trunk
: <root>/home/roland/projects/boost/trunk
;
# Configure a previous version of the library
boost.config 1.34.1
: <include>/home/roland/include/boost-1_34_1
<library>/home/roland/lib
;
And in a Jamfile that needs to link to boost libraries:
using boost : 1.35 ;
exe myexe
: mysrc.cpp
: <library>/boost//program_options
<variant>release
<link>static
;
To use the library from source tree instead you simply
would need to replace the using by:
using boost : trunk ;
The module is intended to be installed into the boost-build tools
directory. It has provisions to take care of different library
setups and tagging rules.
I would be glad to contribute the code to boost if there is
interest.
Regards speedsnail
-- _________________________________________ _ _ | Roland Schwarz |_)(_ | aka. speedsnail | \__) | mailto:roland.schwarz_at_[hidden] ________| http://www.blackspace.at
# $Id: $
# 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:
#
# import boost ;
#
# boost.config 1.35 : <root>/path-to-boost-root ;
#
# If the location to a pre-built version is known:
#
# boost.config 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 'using' statement into your
# Jamfile:
#
# using boost : 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:
#
# using boost ;
#
# 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 modules ;
import errors ;
import project ;
import string ;
import toolset ;
import property-set ;
import regex ;
import common ;
import option ;
.boost.auto_config = [ property-set.create <layout>system ] ;
if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ]
{
.debug-configuration = true ;
}
# 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.
#
rule config
(
version # Version identifier.
: options * # Set the option properties.
)
{
if $(.boost.$(version)) {
errors.user-error
"Boost " $(version) "already configured." ;
}
else {
if $(.debug-configuration) {
if ! $(.boost_default) {
echo notice: configuring default boost library $(version) ;
}
echo notice: configuring boost library $(version) ;
}
.boost_default ?= $(version) ; # the first configured is default
.boost.$(version) = [ property-set.create $(options) ] ;
}
}
# Called by 'toolset.using boost ;' .
#
# The initialisation 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 attemted.
#
rule init
(
version ? # The version of the library to use.
)
{
version ?= $(.boost_default) ;
version ?= auto_config ;
if $(.initialized) {
if $(.initialized) != $(version) {
errors.user-error
"Attempt to use" $(__name__) "with different parameters" ;
}
}
else {
if $(.boost.$(version)) {
local opt = $(.boost.$(version)) ;
local root = [ $(opt).get <root> ] ;
local inc = [ $(opt).get <include> ] ;
local lib = [ $(opt).get <library> ] ;
if $(.debug-configuration) {
echo notice: using boost library $(version) [ $(opt).raw ] ;
}
.layout = [ $(opt).get <layout> ] ;
.layout ?= versioned ;
.build_id = [ $(opt).get <build-id> ] ;
.version_tag = [ regex.replace $(version) "[*\\/:.\"\' ]" "_" ] ;
.initialized = $(version) ;
if ( $(root) && $(inc) )
|| ( $(root) && $(lib) )
|| ( $(lib) && ! $(inc) )
|| ( ! $(lib) && $(inc) ) {
errors.user-error
"Ambiguous parameters,"
"use either <root> or <inlude> with <library>." ;
}
else if ! $(root) && ! $(inc) {
root = [ modules.peek : BOOST_ROOT ] ;
}
local prj = [ project.current ] ;
local mod = [ $(prj).project-module ] ;
if $(root) {
modules.call-in $(mod) : use-project boost : $(root) ;
}
else {
project.initialize $(__name__) ;
# It is possible to overide the setup of the searched
# libraries per version. The (unlikely) tag 0.0.1 is
# meant as an example template only.
switch $(version) {
case 0.0.1 : boost_0_0_1 $(inc) $(lib) ;
case * : boost_std $(inc) $(lib) ;
}
project.act-as-jamfile boost : $(__name__) ;
modules.call-in $(mod) : use-project boost : $(__name__) ;
}
}
else {
errors.user-error
"Reference to unconfigured boost version." ;
}
}
}
rule boost_std ( inc ? lib ? )
{
# The default definitions for pre-built libraries.
project boost
: usage-requirements <include>$(inc)
: requirements <tag>@tag_std <search>$(lib)
;
alias boost_header_only ;
lib program_options : : : :
<link>shared:<define>BOOST_PROGRAM_OPTIONS_DYN_LINK ;
lib thread : : : :
<link>shared:<define>BOOST_THREAD_DYN_DLL ;
lib iostreams : : : :
<link>shared:<define>BOOST_IOSTREAMS_DYN_LINK ;
lib wave : : : :
<link>shared:<define>BOOST_WAVE_DYN_LINK ;
lib python : : : :
<link>shared:<define>BOOST_PYTHON_DYN_LINK ;
lib serialization : : : :
<link>shared:<define>BOOST_SERIALIZATION_DYN_LINK ;
lib graph : : : :
<link>shared:<define>BOOST_GRAPH_DYN_LINK ;
lib date_time : : : :
<link>shared:<define>BOOST_DATE_TIME_DYN_LINK ;
lib test : : : :
<link>shared:<define>BOOST_TEST_DYN_LINK ;
lib regex : : : :
<link>shared:<define>BOOST_REGEX_DYN_LINK ;
lib filesystem : : : :
<link>shared:<define>BOOST_FILE_SYSTEM_DYN_LINK ;
lib signals : : : :
<link>shared:<define>BOOST_SIGNALS_DYN_LINK ;
lib function_types ;
lib mpi : : : :
<link>shared:<define>BOOST_MPI_DYN_LINK ;
lib system : : : :
<link>shared:<define>BOOST_SYSTEM_DYN_LINK ;
}
rule boost_0_0_1 ( inc ? lib ? )
{
echo "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.
}
rule tag_std ( name : type ? : property-set )
{
name = boost_$(name) ;
if ( [ $(property-set).get <link> ] in static ) &&
( [ $(property-set).get <target-os> ] in windows )
{
name = lib$(name) ;
}
if $(.layout) = versioned
{
version = $(.version_tag) ;
toolset = <toolset> ;
}
return [ common.format-name
<base> $(toolset) <threading> <runtime> -$(version) -$(.build_id)
: $(name) : $(type) : $(property-set) ] ;
}
Boost-Build list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk