/usr/share/boost-build/util/indirect.jam is in libboost1.55-tools-dev 1.55.0-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 | # Copyright 2003 Dave Abrahams
# Copyright 2003 Vladimir Prus
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
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 ;
# If the rule name includes a Jamfile module, grab it.
local module-context = [ MATCH ^(Jamfile<[^>]*>)\\..* : $(rulename) ] ;
if ! $(module-context)
{
# Take the first dot-separated element as module name. This disallows
# module names with dots, but allows rule names with dots.
module-context = [ MATCH ^([^.]*)\\..* : $(rulename) ] ;
}
module-context ?= [ CALLER_MODULE $(frames) ] ;
return [ make $(rulename) $(bound-args) : $(module-context) ] ;
}
}
# Returns 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]) ;
}
# Returns 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) : $(10) : $(11) :
$(12) : $(13) : $(14) : $(15) : $(16) : $(17) : $(18) : $(19) ] ;
}
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 ;
}
|