make: Static Usage
4.12.1 Syntax of Static Pattern Rules
-------------------------------------
Here is the syntax of a static pattern rule:
TARGETS ...: TARGET-PATTERN: PREREQ-PATTERNS ...
RECIPE
...
The TARGETS list specifies the targets that the rule applies to. The
targets can contain wildcard characters, just like the targets of
ordinary rules (Using Wildcard Characters in File Names
Wildcards.).
The TARGET-PATTERN and PREREQ-PATTERNS say how to compute the
prerequisites of each target. Each target is matched against the
TARGET-PATTERN to extract a part of the target name, called the "stem".
This stem is substituted into each of the PREREQ-PATTERNS to make the
prerequisite names (one from each PREREQ-PATTERN).
Each pattern normally contains the character '%' just once. When the
TARGET-PATTERN matches a target, the '%' can match any part of the
target name; this part is called the "stem". The rest of the pattern
must match exactly. For example, the target 'foo.o' matches the pattern
'%.o', with 'foo' as the stem. The targets 'foo.c' and 'foo.out' do not
match that pattern.
The prerequisite names for each target are made by substituting the
stem for the '%' in each prerequisite pattern. For example, if one
prerequisite pattern is '%.c', then substitution of the stem 'foo' gives
the prerequisite name 'foo.c'. It is legitimate to write a prerequisite
pattern that does not contain '%'; then this prerequisite is the same
for all targets.
'%' characters in pattern rules can be quoted with preceding
backslashes ('\'). Backslashes that would otherwise quote '%'
characters can be quoted with more backslashes. Backslashes that quote
'%' characters or other backslashes are removed from the pattern before
it is compared to file names or has a stem substituted into it.
Backslashes that are not in danger of quoting '%' characters go
unmolested. For example, the pattern 'the\%weird\\%pattern\\' has
'the%weird\' preceding the operative '%' character, and 'pattern\\'
following it. The final two backslashes are left alone because they
cannot affect any '%' character.
Here is an example, which compiles each of 'foo.o' and 'bar.o' from
the corresponding '.c' file:
objects = foo.o bar.o
all: $(objects)
$(objects): %.o: %.c
$(CC) -c $(CFLAGS) $< -o $@
Here '$<' is the automatic variable that holds the name of the
prerequisite and '$@' is the automatic variable that holds the name of
the target; see Automatic Variables.
Each target specified must match the target pattern; a warning is
issued for each target that does not. If you have a list of files, only
some of which will match the pattern, you can use the 'filter' function
to remove non-matching file names (Functions for String
Substitution and Analysis Text Functions.):
files = foo.elc bar.o lose.o
$(filter %.o,$(files)): %.o: %.c
$(CC) -c $(CFLAGS) $< -o $@
$(filter %.elc,$(files)): %.elc: %.el
emacs -f batch-byte-compile $<
In this example the result of '$(filter %.o,$(files))' is 'bar.o
lose.o', and the first static pattern rule causes each of these object
files to be updated by compiling the corresponding C source file. The
result of '$(filter %.elc,$(files))' is 'foo.elc', so that file is made
from 'foo.el'.
Another example shows how to use '$*' in static pattern rules:
bigoutput littleoutput : %output : text.g
generate text.g -$* > $@
When the 'generate' command is run, '$*' will expand to the stem, either
'big' or 'little'.