mirror of
https://github.com/boostorg/build.git
synced 2026-02-16 01:12:13 +00:00
0d939c9025
(make-qualified): Bugfix. When processing gcc.link.dll rule, take 'gcc' as module name, not 'gcc.link'. The previous behaviour caused 'gcc.link.dll' to be called in context of 'gcc.link' module. As the result the global definition of 'gcc.link.dll' was called. That definition is created by jam when it sees 'actions gcc.link.dll' and has no executable code associated with it. So, rule 'gcc.link.dll' was never executed. [SVN r20009]
103 lines
2.9 KiB
Plaintext
Executable File
103 lines
2.9 KiB
Plaintext
Executable File
# Copyright David Abrahams 2003. Permission to copy, use,
|
|
# modify, sell and distribute this software is granted provided this
|
|
# copyright notice appears in all copies. This software is provided
|
|
# "as is" without express or implied warranty, and with no claim as
|
|
# to its suitability for any purpose.
|
|
import modules ;
|
|
import numbers ;
|
|
|
|
# The pattern that indirect rules must match: module$rule
|
|
.pattern = ^([^%]*)%([^%]+)$ ;
|
|
|
|
#
|
|
# Type checking rules.
|
|
#
|
|
local rule indirect-rule ( x )
|
|
{
|
|
if ! [ MATCH $(.pattern) : $(x) ]
|
|
{
|
|
return "expected a string of the form module$rule, but got \""$(x)"\" for argument" ;
|
|
}
|
|
}
|
|
|
|
# make an indirect rule which calls the given rule; if context is
|
|
# supplied it is expected to be the module in which to invoke the rule
|
|
# by the 'call' rule below. Otherwise, the rule will be invoked in
|
|
# the module of this rule's caller.
|
|
rule make ( rulename bound-args * : context ? )
|
|
{
|
|
context ?= [ CALLER_MODULE ] ;
|
|
context ?= "" ;
|
|
return $(context)%$(rulename) $(bound-args) ;
|
|
}
|
|
|
|
# make an indirect rule which calls the given rule. rulename may be a
|
|
# qualified rule; if so it is returned unchanged. Otherwise, if
|
|
# frames is not supplied, the result will be invoked (by 'call',
|
|
# below) in the module of the caller. Otherwise, frames > 1
|
|
# specifies additional call frames to back up in order to find the
|
|
# module context.
|
|
rule make-qualified ( rulename bound-args * : frames ? )
|
|
{
|
|
if [ MATCH $(.pattern) : $(rulename) ]
|
|
{
|
|
return $(rulename) $(bound-args) ;
|
|
}
|
|
else
|
|
{
|
|
frames ?= 1 ;
|
|
# Take the first dot-separated element as module name.
|
|
# This disallows module names with dots, but allows rule names
|
|
# with dots.
|
|
local module-context = [ MATCH ^([^.]*)\\..* : $(rulename) ] ;
|
|
module-context ?= [ CALLER_MODULE $(frames) ] ;
|
|
return [ make $(rulename) $(bound-args) : $(module-context) ] ;
|
|
}
|
|
}
|
|
|
|
# return the module name in which the given indirect rule will be
|
|
# invoked.
|
|
rule get-module ( [indirect-rule] x )
|
|
{
|
|
local m = [ MATCH $(.pattern) : $(x) ] ;
|
|
if ! $(m[1])
|
|
{
|
|
m = ;
|
|
}
|
|
return $(m[1]) ;
|
|
}
|
|
|
|
# return the rulename that will be called when x is invoked
|
|
rule get-rule ( [indirect-rule] x )
|
|
{
|
|
local m = [ MATCH $(.pattern) : $(x) ] ;
|
|
return $(m[2]) ;
|
|
}
|
|
|
|
# Invoke the given indirect-rule.
|
|
rule call ( [indirect-rule] r args * : * )
|
|
{
|
|
return [
|
|
modules.call-in [ get-module $(r) ]
|
|
: [ get-rule $(r) ] $(args) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9)
|
|
] ;
|
|
}
|
|
|
|
rule __test__
|
|
{
|
|
import assert ;
|
|
|
|
rule foo-barr! ( x )
|
|
{
|
|
assert.equal $(x) : x ;
|
|
}
|
|
|
|
assert.equal [ get-rule [ make foo-barr! ] ] : foo-barr! ;
|
|
assert.equal [ get-module [ make foo-barr! ] ] : [ CALLER_MODULE ] ;
|
|
|
|
call [ make foo-barr! ] x ;
|
|
call [ make foo-barr! x ] ;
|
|
|
|
|
|
call [ make foo-barr! : [ CALLER_MODULE ] ] x ;
|
|
} |