diff options
Diffstat (limited to 'jam-files/boost-build/tools/builtin.jam')
| -rw-r--r-- | jam-files/boost-build/tools/builtin.jam | 960 |
1 files changed, 0 insertions, 960 deletions
diff --git a/jam-files/boost-build/tools/builtin.jam b/jam-files/boost-build/tools/builtin.jam deleted file mode 100644 index 148e7308..00000000 --- a/jam-files/boost-build/tools/builtin.jam +++ /dev/null @@ -1,960 +0,0 @@ -# Copyright 2002, 2003, 2004, 2005 Dave Abrahams -# Copyright 2002, 2005, 2006, 2007, 2010 Rene Rivera -# Copyright 2006 Juergen Hunold -# Copyright 2005 Toon Knapen -# Copyright 2002, 2003, 2004, 2005, 2006 Vladimir Prus -# 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) - -# Defines standard features and rules. - -import alias ; -import "class" : new ; -import errors ; -import feature ; -import generators ; -import numbers ; -import os ; -import path ; -import print ; -import project ; -import property ; -import regex ; -import scanner ; -import sequence ; -import stage ; -import symlink ; -import toolset ; -import type ; -import targets ; -import types/register ; -import utility ; -import virtual-target ; -import message ; -import convert ; - -# FIXME: the following generate module import is not needed here but removing it -# too hastly will break using code (e.g. the main Boost library Jamroot file) -# that forgot to import the generate module before calling the generate rule. -import generate ; - - -.os-names = aix bsd cygwin darwin freebsd hpux iphone linux netbsd - openbsd osf qnx qnxnto sgi solaris unix unixware windows - elf # Not actually an OS -- used for targeting bare metal where - # object format is ELF. This catches both -elf and -eabi gcc - # targets and well as other compilers targeting ELF. It is not - # clear how often do we need to key of ELF specifically as opposed - # to other bare metal targets, but let's stick with gcc naming. - ; - -# Feature used to determine which OS we're on. New <target-os> and <host-os> -# features should be used instead. -local os = [ modules.peek : OS ] ; -feature.feature os : $(os) : propagated link-incompatible ; - - -# Translates from bjam current OS to the os tags used in host-os and target-os, -# i.e. returns the running host-os. -# -local rule default-host-os ( ) -{ - local host-os ; - if [ os.name ] in $(.os-names:U) - { - host-os = [ os.name ] ; - } - else - { - switch [ os.name ] - { - case NT : host-os = windows ; - case AS400 : host-os = unix ; - case MINGW : host-os = windows ; - case BSDI : host-os = bsd ; - case COHERENT : host-os = unix ; - case DRAGONFLYBSD : host-os = bsd ; - case IRIX : host-os = sgi ; - case MACOSX : host-os = darwin ; - case KFREEBSD : host-os = freebsd ; - case LINUX : host-os = linux ; - case SUNOS : - ECHO "SunOS is not a supported operating system." ; - ECHO "We believe last version of SunOS was released in 1992, " ; - ECHO "so if you get this message, something is very wrong with configuration logic. " ; - ECHO "Please report this as a bug. " ; - EXIT ; - case * : host-os = unix ; - } - } - return $(host-os:L) ; -} - - -# The two OS features define a known set of abstract OS names. The host-os is -# the OS under which bjam is running. Even though this should really be a fixed -# property we need to list all the values to prevent unknown value errors. Both -# set the default value to the current OS to account for the default use case of -# building on the target OS. -feature.feature host-os : $(.os-names) ; -feature.set-default host-os : [ default-host-os ] ; - -feature.feature target-os : $(.os-names) : propagated link-incompatible ; -feature.set-default target-os : [ default-host-os ] ; - - -feature.feature toolset : : implicit propagated symmetric ; -feature.feature stdlib : native : propagated composite ; -feature.feature link : shared static : propagated ; -feature.feature runtime-link : shared static : propagated ; -feature.feature runtime-debugging : on off : propagated ; -feature.feature optimization : off speed space none : propagated ; -feature.feature profiling : off on : propagated ; -feature.feature inlining : off on full : propagated ; -feature.feature threading : single multi : propagated ; -feature.feature rtti : on off : propagated ; -feature.feature exception-handling : on off : propagated ; - -# Whether there is support for asynchronous EH (e.g. catching SEGVs). -feature.feature asynch-exceptions : off on : propagated ; - -# Whether all extern "C" functions are considered nothrow by default. -feature.feature extern-c-nothrow : off on : propagated ; - -feature.feature debug-symbols : on off none : propagated ; -# Controls whether the binary should be stripped -- that is have -# everything not necessary to running removed. This option should -# not be very often needed. Also, this feature will show up in -# target paths of everything, not just binaries. Should fix that -# when impelementing feature relevance. -feature.feature strip : off on : propagated ; -feature.feature define : : free ; -feature.feature undef : : free ; -feature.feature "include" : : free path ; #order-sensitive ; -feature.feature cflags : : free ; -feature.feature cxxflags : : free ; -feature.feature fflags : : free ; -feature.feature asmflags : : free ; -feature.feature linkflags : : free ; -feature.feature archiveflags : : free ; -feature.feature version : : free ; - -# Generic, i.e. non-language specific, flags for tools. -feature.feature flags : : free ; -feature.feature location-prefix : : free ; - - -# The following features are incidental since they have no effect on built -# products. Not making them incidental will result in problems in corner cases, -# e.g.: -# -# unit-test a : a.cpp : <use>b ; -# lib b : a.cpp b ; -# -# Here, if <use> is not incidental, we would decide we have two targets for -# a.obj with different properties and complain about it. -# -# Note that making a feature incidental does not mean it is ignored. It may be -# ignored when creating a virtual target, but the rest of build process will use -# them. -feature.feature use : : free dependency incidental ; -feature.feature dependency : : free dependency incidental ; -feature.feature implicit-dependency : : free dependency incidental ; - -feature.feature warnings : - on # Enable default/"reasonable" warning level for the tool. - all # Enable all possible warnings issued by the tool. - off # Disable all warnings issued by the tool. - : incidental propagated ; - -feature.feature warnings-as-errors : - off # Do not fail the compilation if there are warnings. - on # Fail the compilation if there are warnings. - : incidental propagated ; - -# Feature that allows us to configure the maximal template instantiation depth -# level allowed by a C++ compiler. Applies only to C++ toolsets whose compilers -# actually support this configuration setting. -# -# Note that Boost Build currently does not allow defining features that take any -# positive integral value as a parameter, which is what we need here, so we just -# define some of the values here and leave it up to the user to extend this set -# as he needs using the feature.extend rule. -# -# TODO: This should be upgraded as soon as Boost Build adds support for custom -# validated feature values or at least features allowing any positive integral -# value. See related Boost Build related trac ticket #194. -# -feature.feature c++-template-depth - : - [ numbers.range 64 1024 : 64 ] - [ numbers.range 20 1000 : 10 ] - # Maximum template instantiation depth guaranteed for ANSI/ISO C++ - # conforming programs. - 17 - : - incidental optional propagated ; - -feature.feature source : : free dependency incidental ; -feature.feature library : : free dependency incidental ; -feature.feature file : : free dependency incidental ; -feature.feature find-shared-library : : free ; #order-sensitive ; -feature.feature find-static-library : : free ; #order-sensitive ; -feature.feature library-path : : free path ; #order-sensitive ; - -# Internal feature. -feature.feature library-file : : free dependency ; - -feature.feature name : : free ; -feature.feature tag : : free ; -feature.feature search : : free path ; #order-sensitive ; -feature.feature location : : free path ; -feature.feature dll-path : : free path ; -feature.feature hardcode-dll-paths : true false : incidental ; - - -# An internal feature that holds the paths of all dependency shared libraries. -# On Windows, it is needed so that we can add all those paths to PATH when -# running applications. On Linux, it is needed to add proper -rpath-link command -# line options. -feature.feature xdll-path : : free path ; - -# Provides means to specify def-file for windows DLLs. -feature.feature def-file : : free dependency ; - -feature.feature suppress-import-lib : false true : incidental ; - -# Internal feature used to store the name of a bjam action to call when building -# a target. -feature.feature action : : free ; - -# This feature is used to allow specific generators to run. For example, QT -# tools can only be invoked when QT library is used. In that case, <allow>qt -# will be in usage requirement of the library. -feature.feature allow : : free ; - -# The addressing model to generate code for. Currently a limited set only -# specifying the bit size of pointers. -feature.feature address-model : 16 32 64 32_64 : propagated optional ; - -# Type of CPU architecture to compile for. -feature.feature architecture : - # x86 and x86-64 - x86 - - # ia64 - ia64 - - # Sparc - sparc - - # RS/6000 & PowerPC - power - - # MIPS/SGI - mips1 mips2 mips3 mips4 mips32 mips32r2 mips64 - - # HP/PA-RISC - parisc - - # Advanced RISC Machines - arm - - # Combined architectures for platforms/toolsets that support building for - # multiple architectures at once. "combined" would be the default multi-arch - # for the toolset. - combined - combined-x86-power - - : propagated optional ; - -# The specific instruction set in an architecture to compile. -feature.feature instruction-set : - # x86 and x86-64 - native i386 i486 i586 i686 pentium pentium-mmx pentiumpro pentium2 pentium3 - pentium3m pentium-m pentium4 pentium4m prescott nocona core2 conroe conroe-xe - conroe-l allendale mermon mermon-xe kentsfield kentsfield-xe penryn wolfdale - yorksfield nehalem k6 k6-2 k6-3 athlon athlon-tbird athlon-4 athlon-xp - athlon-mp k8 opteron athlon64 athlon-fx winchip-c6 winchip2 c3 c3-2 - - # ia64 - itanium itanium1 merced itanium2 mckinley - - # Sparc - v7 cypress v8 supersparc sparclite hypersparc sparclite86x f930 f934 - sparclet tsc701 v9 ultrasparc ultrasparc3 - - # RS/6000 & PowerPC - 401 403 405 405fp 440 440fp 505 601 602 603 603e 604 604e 620 630 740 7400 - 7450 750 801 821 823 860 970 8540 power-common ec603e g3 g4 g5 power power2 - power3 power4 power5 powerpc powerpc64 rios rios1 rsc rios2 rs64a - - # MIPS - 4kc 4kp 5kc 20kc m4k r2000 r3000 r3900 r4000 r4100 r4300 r4400 r4600 r4650 - r6000 r8000 rm7000 rm9000 orion sb1 vr4100 vr4111 vr4120 vr4130 vr4300 - vr5000 vr5400 vr5500 - - # HP/PA-RISC - 700 7100 7100lc 7200 7300 8000 - - # Advanced RISC Machines - armv2 armv2a armv3 armv3m armv4 armv4t armv5 armv5t armv5te armv6 armv6j iwmmxt ep9312 - - : propagated optional ; - -# Used to select a specific variant of C++ ABI if the compiler supports several. -feature.feature c++abi : : propagated optional ; - -feature.feature conditional : : incidental free ; - -# The value of 'no' prevents building of a target. -feature.feature build : yes no : optional ; - -# Windows-specific features - -feature.feature user-interface : console gui wince native auto ; - -feature.feature variant : : implicit composite propagated symmetric ; - - -# Declares a new variant. -# -# First determines explicit properties for this variant, by refining parents' -# explicit properties with the passed explicit properties. The result is -# remembered and will be used if this variant is used as parent. -# -# Second, determines the full property set for this variant by adding to the -# explicit properties default values for all missing non-symmetric properties. -# -# Lastly, makes appropriate value of 'variant' property expand to the full -# property set. -# -rule variant ( name # Name of the variant - : parents-or-properties * # Specifies parent variants, if - # 'explicit-properties' are given, and - # explicit-properties or parents otherwise. - : explicit-properties * # Explicit properties. - ) -{ - local parents ; - if ! $(explicit-properties) - { - if $(parents-or-properties[1]:G) - { - explicit-properties = $(parents-or-properties) ; - } - else - { - parents = $(parents-or-properties) ; - } - } - else - { - parents = $(parents-or-properties) ; - } - - # The problem is that we have to check for conflicts between base variants. - if $(parents[2]) - { - errors.error "multiple base variants are not yet supported" ; - } - - local inherited ; - # Add explicitly specified properties for parents. - for local p in $(parents) - { - # TODO: This check may be made stricter. - if ! [ feature.is-implicit-value $(p) ] - { - errors.error "Invalid base variant" $(p) ; - } - - inherited += $(.explicit-properties.$(p)) ; - } - property.validate $(explicit-properties) ; - explicit-properties = [ property.refine $(inherited) - : $(explicit-properties) ] ; - - # Record explicitly specified properties for this variant. We do this after - # inheriting parents' properties so they affect other variants derived from - # this one. - .explicit-properties.$(name) = $(explicit-properties) ; - - feature.extend variant : $(name) ; - feature.compose <variant>$(name) : $(explicit-properties) ; -} -IMPORT $(__name__) : variant : : variant ; - - -variant debug : <optimization>off <debug-symbols>on <inlining>off - <runtime-debugging>on ; -variant release : <optimization>speed <debug-symbols>off <inlining>full - <runtime-debugging>off <define>NDEBUG ; -variant profile : release : <profiling>on <debug-symbols>on ; - - -class searched-lib-target : abstract-file-target -{ - rule __init__ ( name - : project - : shared ? - : search * - : action - ) - { - abstract-file-target.__init__ $(name) : SEARCHED_LIB : $(project) - : $(action) : ; - - self.shared = $(shared) ; - self.search = $(search) ; - } - - rule shared ( ) - { - return $(self.shared) ; - } - - rule search ( ) - { - return $(self.search) ; - } - - rule actualize-location ( target ) - { - NOTFILE $(target) ; - } - - rule path ( ) - { - } -} - - -# The generator class for libraries (target type LIB). Depending on properties -# it will request building of the appropriate specific library type -- -# -- SHARED_LIB, STATIC_LIB or SHARED_LIB. -# -class lib-generator : generator -{ - rule __init__ ( * : * ) - { - generator.__init__ $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ; - } - - rule run ( project name ? : property-set : sources * ) - { - # The lib generator is composing, and can be only invoked with an - # explicit name. This check is present in generator.run (and so in - # builtin.linking-generator) but duplicated here to avoid doing extra - # work. - if $(name) - { - local properties = [ $(property-set).raw ] ; - # Determine the needed target type. - local actual-type ; - # <source>files can be generated by <conditional>@rule feature - # in which case we do not consider it a SEARCHED_LIB type. - if ! <source> in $(properties:G) && - ( <search> in $(properties:G) || <name> in $(properties:G) ) - { - actual-type = SEARCHED_LIB ; - } - else if <file> in $(properties:G) - { - actual-type = LIB ; - } - else if <link>shared in $(properties) - { - actual-type = SHARED_LIB ; - } - else - { - actual-type = STATIC_LIB ; - } - property-set = [ $(property-set).add-raw <main-target-type>LIB ] ; - # Construct the target. - return [ generators.construct $(project) $(name) : $(actual-type) - : $(property-set) : $(sources) ] ; - } - } - - rule viable-source-types ( ) - { - return * ; - } -} - - -generators.register [ new lib-generator builtin.lib-generator : : LIB ] ; - - -# The implementation of the 'lib' rule. Beyond standard syntax that rule allows -# simplified: "lib a b c ;". -# -rule lib ( names + : sources * : requirements * : default-build * : - usage-requirements * ) -{ - if $(names[2]) - { - if <name> in $(requirements:G) - { - errors.user-error "When several names are given to the 'lib' rule" : - "it is not allowed to specify the <name> feature." ; - } - if $(sources) - { - errors.user-error "When several names are given to the 'lib' rule" : - "it is not allowed to specify sources." ; - } - } - - # This is a circular module dependency so it must be imported here. - import targets ; - - local project = [ project.current ] ; - local result ; - - for local name in $(names) - { - local r = $(requirements) ; - # Support " lib a ; " and " lib a b c ; " syntax. - if ! $(sources) && ! <name> in $(requirements:G) - && ! <file> in $(requirements:G) - { - r += <name>$(name) ; - } - result += [ targets.main-target-alternative - [ new typed-target $(name) : $(project) : LIB - : [ targets.main-target-sources $(sources) : $(name) ] - : [ targets.main-target-requirements $(r) : $(project) ] - : [ targets.main-target-default-build $(default-build) : $(project) ] - : [ targets.main-target-usage-requirements $(usage-requirements) : $(project) ] - ] ] ; - } - return $(result) ; -} -IMPORT $(__name__) : lib : : lib ; - - -class searched-lib-generator : generator -{ - import property-set ; - - rule __init__ ( ) - { - # The requirements cause the generators to be tried *only* when we're - # building a lib target with a 'search' feature. This seems ugly --- all - # we want is to make sure searched-lib-generator is not invoked deep - # inside transformation search to produce intermediate targets. - generator.__init__ searched-lib-generator : : SEARCHED_LIB ; - } - - rule run ( project name ? : property-set : sources * ) - { - if $(name) - { - # If 'name' is empty, it means we have not been called to build a - # top-level target. In this case, we just fail immediately, because - # searched-lib-generator cannot be used to produce intermediate - # targets. - - local properties = [ $(property-set).raw ] ; - local shared ; - if <link>shared in $(properties) - { - shared = true ; - } - - local search = [ feature.get-values <search> : $(properties) ] ; - - local a = [ new null-action $(property-set) ] ; - local lib-name = [ feature.get-values <name> : $(properties) ] ; - lib-name ?= $(name) ; - local t = [ new searched-lib-target $(lib-name) : $(project) - : $(shared) : $(search) : $(a) ] ; - # We return sources for a simple reason. If there is - # lib png : z : <name>png ; - # the 'z' target should be returned, so that apps linking to 'png' - # will link to 'z', too. - return [ property-set.create <xdll-path>$(search) ] - [ virtual-target.register $(t) ] $(sources) ; - } - } -} - -generators.register [ new searched-lib-generator ] ; - - -class prebuilt-lib-generator : generator -{ - rule __init__ ( * : * ) - { - generator.__init__ $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ; - } - - rule run ( project name ? : property-set : sources * ) - { - local f = [ $(property-set).get <file> ] ; - return $(f) $(sources) ; - } -} - -generators.register - [ new prebuilt-lib-generator builtin.prebuilt : : LIB : <file> ] ; - -generators.override builtin.prebuilt : builtin.lib-generator ; - -class preprocessed-target-class : basic-target -{ - import generators ; - rule construct ( name : sources * : property-set ) - { - local result = [ generators.construct [ project ] - $(name) : PREPROCESSED_CPP : $(property-set) : $(sources) ] ; - if ! $(result) - { - result = [ generators.construct [ project ] - $(name) : PREPROCESSED_C : $(property-set) : $(sources) ] ; - } - if ! $(result) - { - local s ; - for x in $(sources) - { - s += [ $(x).name ] ; - } - local p = [ project ] ; - errors.user-error - "In project" [ $(p).name ] : - "Could not construct preprocessed file \"$(name)\" from $(s:J=, )." ; - } - return $(result) ; - } -} - -rule preprocessed ( name : sources * : requirements * : default-build * : - usage-requirements * ) -{ - local project = [ project.current ] ; - return [ targets.main-target-alternative - [ new preprocessed-target-class $(name) : $(project) - : [ targets.main-target-sources $(sources) : $(name) ] - : [ targets.main-target-requirements $(r) : $(project) ] - : [ targets.main-target-default-build $(default-build) : $(project) ] - : [ targets.main-target-usage-requirements $(usage-requirements) : $(project) ] - ] ] ; -} - -IMPORT $(__name__) : preprocessed : : preprocessed ; - -class compile-action : action -{ - import sequence ; - - rule __init__ ( targets * : sources * : action-name : properties * ) - { - action.__init__ $(targets) : $(sources) : $(action-name) : $(properties) ; - } - - # For all virtual targets for the same dependency graph as self, i.e. which - # belong to the same main target, add their directories to the include path. - # - rule adjust-properties ( property-set ) - { - local s = [ $(self.targets[1]).creating-subvariant ] ; - return [ $(property-set).add-raw - [ $(s).implicit-includes "include" : H ] ] ; - } -} - - -# Declare a special compiler generator. The only thing it does is changing the -# type used to represent 'action' in the constructed dependency graph to -# 'compile-action'. That class in turn adds additional include paths to handle -# cases when a source file includes headers which are generated themselves. -# -class C-compiling-generator : generator -{ - rule __init__ ( id : source-types + : target-types + : requirements * - : optional-properties * ) - { - generator.__init__ $(id) : $(source-types) : $(target-types) : - $(requirements) : $(optional-properties) ; - } - - rule action-class ( ) - { - return compile-action ; - } -} - - -rule register-c-compiler ( id : source-types + : target-types + : requirements * - : optional-properties * ) -{ - generators.register [ new C-compiling-generator $(id) : $(source-types) : - $(target-types) : $(requirements) : $(optional-properties) ] ; -} - -# FIXME: this is ugly, should find a better way (we would like client code to -# register all generators as "generators.some-rule" instead of -# "some-module.some-rule".) -# -IMPORT $(__name__) : register-c-compiler : : generators.register-c-compiler ; - - -# The generator class for handling EXE and SHARED_LIB creation. -# -class linking-generator : generator -{ - import path ; - import project ; - import property-set ; - import type ; - - rule __init__ ( id - composing ? : # The generator will be composing if a non-empty - # string is passed or the parameter is not given. To - # make the generator non-composing, pass an empty - # string (""). - source-types + : - target-types + : - requirements * ) - { - composing ?= true ; - generator.__init__ $(id) $(composing) : $(source-types) - : $(target-types) : $(requirements) ; - } - - rule run ( project name ? : property-set : sources + ) - { - sources += [ $(property-set).get <library> ] ; - - # Add <library-path> properties for all searched libraries. - local extra ; - for local s in $(sources) - { - if [ $(s).type ] = SEARCHED_LIB - { - local search = [ $(s).search ] ; - extra += <library-path>$(search) ; - } - } - - # It is possible that sources include shared libraries that did not came - # from 'lib' targets, e.g. .so files specified as sources. In this case - # we have to add extra dll-path properties and propagate extra xdll-path - # properties so that application linking to us will get xdll-path to - # those libraries. - local extra-xdll-paths ; - for local s in $(sources) - { - if [ type.is-derived [ $(s).type ] SHARED_LIB ] && ! [ $(s).action ] - { - # Unfortunately, we do not have a good way to find the path to a - # file, so use this nasty approach. - # - # TODO: This needs to be done better. One thing that is really - # broken with this is that it does not work correctly with - # projects having multiple source locations. - local p = [ $(s).project ] ; - local location = [ path.root [ $(s).name ] - [ $(p).get source-location ] ] ; - extra-xdll-paths += [ path.parent $(location) ] ; - } - } - - # Hardcode DLL paths only when linking executables. - # Pros: do not need to relink libraries when installing. - # Cons: "standalone" libraries (plugins, python extensions) can not - # hardcode paths to dependent libraries. - if [ $(property-set).get <hardcode-dll-paths> ] = true - && [ type.is-derived $(self.target-types[1]) EXE ] - { - local xdll-path = [ $(property-set).get <xdll-path> ] ; - extra += <dll-path>$(xdll-path) <dll-path>$(extra-xdll-paths) ; - } - - if $(extra) - { - property-set = [ $(property-set).add-raw $(extra) ] ; - } - - local result = [ generator.run $(project) $(name) : $(property-set) - : $(sources) ] ; - - local ur ; - if $(result) - { - ur = [ extra-usage-requirements $(result) : $(property-set) ] ; - ur = [ $(ur).add - [ property-set.create <xdll-path>$(extra-xdll-paths) ] ] ; - } - return $(ur) $(result) ; - } - - rule extra-usage-requirements ( created-targets * : property-set ) - { - local result = [ property-set.empty ] ; - local extra ; - - # Add appropricate <xdll-path> usage requirements. - local raw = [ $(property-set).raw ] ; - if <link>shared in $(raw) - { - local paths ; - local pwd = [ path.pwd ] ; - for local t in $(created-targets) - { - if [ type.is-derived [ $(t).type ] SHARED_LIB ] - { - paths += [ path.root [ path.make [ $(t).path ] ] $(pwd) ] ; - } - } - extra += $(paths:G=<xdll-path>) ; - } - - # We need to pass <xdll-path> features that we've got from sources, - # because if a shared library is built, exe using it needs to know paths - # to other shared libraries this one depends on in order to be able to - # find them all at runtime. - - # Just pass all features in property-set, it is theorically possible - # that we will propagate <xdll-path> features explicitly specified by - # the user, but then the user is to blaim for using an internal feature. - local values = [ $(property-set).get <xdll-path> ] ; - extra += $(values:G=<xdll-path>) ; - - if $(extra) - { - result = [ property-set.create $(extra) ] ; - } - return $(result) ; - } - - rule generated-targets ( sources + : property-set : project name ? ) - { - local sources2 ; # Sources to pass to inherited rule. - local properties2 ; # Properties to pass to inherited rule. - local libraries ; # Library sources. - - # Searched libraries are not passed as arguments to the linker but via - # some option. So, we pass them to the action using a property. - properties2 = [ $(property-set).raw ] ; - local fsa ; - local fst ; - for local s in $(sources) - { - if [ type.is-derived [ $(s).type ] SEARCHED_LIB ] - { - local name = [ $(s).name ] ; - if [ $(s).shared ] - { - fsa += $(name) ; - } - else - { - fst += $(name) ; - } - } - else - { - sources2 += $(s) ; - } - } - properties2 += <find-shared-library>$(fsa:J=&&) - <find-static-library>$(fst:J=&&) ; - - return [ generator.generated-targets $(sources2) - : [ property-set.create $(properties2) ] : $(project) $(name) ] ; - } -} - - -rule register-linker ( id composing ? : source-types + : target-types + - : requirements * ) -{ - generators.register [ new linking-generator $(id) $(composing) - : $(source-types) : $(target-types) : $(requirements) ] ; -} - - -# The generator class for handling STATIC_LIB creation. -# -class archive-generator : generator -{ - import property-set ; - - rule __init__ ( id composing ? : source-types + : target-types + - : requirements * ) - { - composing ?= true ; - generator.__init__ $(id) $(composing) : $(source-types) - : $(target-types) : $(requirements) ; - } - - rule run ( project name ? : property-set : sources + ) - { - sources += [ $(property-set).get <library> ] ; - - local result = [ generator.run $(project) $(name) : $(property-set) - : $(sources) ] ; - - # For static linking, if we get a library in source, we can not directly - # link to it so we need to cause our dependencies to link to that - # library. There are two approaches: - # - adding the library to the list of returned targets. - # - using the <library> usage requirements. - # The problem with the first is: - # - # lib a1 : : <file>liba1.a ; - # lib a2 : a2.cpp a1 : <link>static ; - # install dist : a2 ; - # - # here we will try to install 'a1', even though it is not necessary in - # the general case. With the second approach, even indirect dependants - # will link to the library, but it should not cause any harm. So, return - # all LIB sources together with created targets, so that dependants link - # to them. - local usage-requirements ; - if [ $(property-set).get <link> ] = static - { - for local t in $(sources) - { - if [ type.is-derived [ $(t).type ] LIB ] - { - usage-requirements += <library>$(t) ; - } - } - } - - usage-requirements = [ property-set.create $(usage-requirements) ] ; - - return $(usage-requirements) $(result) ; - } -} - - -rule register-archiver ( id composing ? : source-types + : target-types + - : requirements * ) -{ - generators.register [ new archive-generator $(id) $(composing) - : $(source-types) : $(target-types) : $(requirements) ] ; -} - - -# Generator that accepts everything and produces nothing. Useful as a general -# fallback for toolset-specific actions like PCH generation. -# -class dummy-generator : generator -{ - import property-set ; - - rule run ( project name ? : property-set : sources + ) - { - return [ property-set.empty ] ; - } -} - -IMPORT $(__name__) : register-linker register-archiver - : : generators.register-linker generators.register-archiver ; |