Node:Call Function, Next:Value Function, Previous:If Function, Up:Functions

### 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`.