( Call Function

Info Catalog ( Foreach Function ( Functions ( 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
    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"
      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 ( Foreach Function ( Functions ( Value Function
automatically generated byinfo2html