|GNU Make Manual||www.imodulo.com · 2003-04-05|
|[ Software | Documentation | Contact ]|
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:
make expands this function, it assigns each param to temporary variables
$(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
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).
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
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
This one is slightly more interesting: it defines a macro to search for the first instance of a program in
pathsearch = $(firstword $(wildcard $(addsuffix /$(1),$(subst :, ,$(PATH))))) LS := $(call pathsearch,ls)
Now the variable LS contains
/bin/ls or similar.
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
|© Free Software Foundation, Inc.|