(make.info.gz) Call Function
Info Catalog
(make.info.gz) Foreach Function
(make.info.gz) Functions
(make.info.gz) Value Function
8.6 The `call' Function
=======================
The `call' function is unique in that it can be used to create new
parameterized functions. You can write a complex expression as the
value of a variable, then use `call' to expand it with different values.
The syntax of the `call' function is:
$(call VARIABLE,PARAM,PARAM,...)
When `make' expands this function, it assigns each PARAM to
temporary variables `$(1)', `$(2)', etc. The variable `$(0)' will
contain VARIABLE. There is no maximum number of parameter arguments.
There is no minimum, either, but it doesn't make sense to use `call'
with no parameters.
Then VARIABLE is expanded as a `make' variable in the context of
these temporary assignments. Thus, any reference to `$(1)' in the
value of VARIABLE will resolve to the first PARAM in the invocation of
`call'.
Note that VARIABLE is the _name_ of a variable, not a _reference_ to
that variable. Therefore you would not normally use a `$' or
parentheses when writing it. (You can, however, use a variable
reference in the name if you want the name not to be a constant.)
If VARIABLE is the name of a builtin function, the builtin function
is always invoked (even if a `make' variable by that name also exists).
The `call' function expands the PARAM arguments before assigning
them to temporary variables. This means that VARIABLE values
containing references to builtin functions that have special expansion
rules, like `foreach' or `if', may not work as you expect.
Some examples may make this clearer.
This macro simply reverses its arguments:
reverse = $(2) $(1)
foo = $(call reverse,a,b)
Here FOO will contain `b a'.
This one is slightly more interesting: it defines a macro to search
for the first instance of a program in `PATH':
pathsearch = $(firstword $(wildcard $(addsuffix /$(1),$(subst :, ,$(PATH)))))
LS := $(call pathsearch,ls)
Now the variable LS contains `/bin/ls' or similar.
The `call' function can be nested. Each recursive invocation gets
its own local values for `$(1)', etc. that mask the values of
higher-level `call'. For example, here is an implementation of a "map"
function:
map = $(foreach a,$(2),$(call $(1),$(a)))
Now you can MAP a function that normally takes only one argument,
such as `origin', to multiple values in one step:
o = $(call map,origin,o map MAKE)
and end up with O containing something like `file file default'.
A final caution: be careful when adding whitespace to the arguments
to `call'. As with other functions, any whitespace contained in the
second and subsequent arguments is kept; this can cause strange
effects. It's generally safest to remove all extraneous whitespace when
providing parameters to `call'.
Info Catalog
(make.info.gz) Foreach Function
(make.info.gz) Functions
(make.info.gz) Value Function
automatically generated byinfo2html