(make.info.gz) Canned Recipes

Info Catalog (make.info.gz) Recursion (make.info.gz) Recipes (make.info.gz) Empty Recipes
 
 5.8 Defining Canned Recipes
 ===========================
 
 When the same sequence of commands is useful in making various targets,
 you can define it as a canned sequence with the `define' directive, and
 refer to the canned sequence from the recipes for those targets.  The
 canned sequence is actually a variable, so the name must not conflict
 with other variable names.
 
    Here is an example of defining a canned recipe:
 
      define run-yacc =
      yacc $(firstword $^)
      mv y.tab.c $@
      endef
    
 Here `run-yacc' is the name of the variable being defined; `endef'
 marks the end of the definition; the lines in between are the commands.
 The `define' directive does not expand variable references and function
 calls in the canned sequence; the `$' characters, parentheses, variable
 names, and so on, all become part of the value of the variable you are
 defining.   Defining Multi-Line Variables Multi-Line, for a
 complete explanation of `define'.
 
    The first command in this example runs Yacc on the first
 prerequisite of whichever rule uses the canned sequence.  The output
 file from Yacc is always named `y.tab.c'.  The second command moves the
 output to the rule's target file name.
 
    To use the canned sequence, substitute the variable into the recipe
 of a rule.  You can substitute it like any other variable ( Basics
 of Variable References Reference.).  Because variables defined by
 `define' are recursively expanded variables, all the variable
 references you wrote inside the `define' are expanded now.  For example:
 
      foo.c : foo.y
              $(run-yacc)
 
 `foo.y' will be substituted for the variable `$^' when it occurs in
 `run-yacc''s value, and `foo.c' for `$@'.
 
    This is a realistic example, but this particular one is not needed in
 practice because `make' has an implicit rule to figure out these
 commands based on the file names involved ( Using Implicit Rules
 Implicit Rules.).
 
    In recipe execution, each line of a canned sequence is treated just
 as if the line appeared on its own in the rule, preceded by a tab.  In
 particular, `make' invokes a separate subshell for each line.  You can
 use the special prefix characters that affect command lines (`@', `-',
 and `+') on each line of a canned sequence.   Writing Recipes in
 Rules Recipes.  For example, using this canned sequence:
 
      define frobnicate =
      @echo "frobnicating target $@"
      frob-step-1 $< -o $@-step-1
      frob-step-2 $@-step-1 -o $@
      endef
 
 `make' will not echo the first line, the `echo' command.  But it _will_
 echo the following two recipe lines.
 
    On the other hand, prefix characters on the recipe line that refers
 to a canned sequence apply to every line in the sequence.  So the rule:
 
      frob.out: frob.in
              @$(frobnicate)
 
 does not echo _any_ recipe lines.  ( Recipe Echoing Echoing, for
 a full explanation of `@'.)
 
Info Catalog (make.info.gz) Recursion (make.info.gz) Recipes (make.info.gz) Empty Recipes
automatically generated by info2html