f78
Syntax of Static Pattern Rules
Contents|Index|Previous|Next
Syntax of Static Pattern Rules
The following shows the syntax of a static pattern rule:
targets ...: target-pattern: dep-patterns ...
commands
...
The targets list specifies the targets to which the rule applies. The targets can contain
wildcard characters, just like the targets of ordinary rules (see Using Wildcard Characters in File Names).
The
target-pattern and dep-patterns say how to compute the dependencies 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
dep-patterns to make the dependency names (one from each dep-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 dependency names for each target are made by substituting the stem for the
% in each dependency pattern. For example, if one dependency pattern is %.c, then substitution of the stem foo gives the dependency name foo.c. It is legitimate to write a dependency pattern that does not contain %; then this dependency is the same for all targets.
% characters in pattern rules can be quoted with preceding back-slashes (\). 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.
The following is an example which compiles each of
foo.o and bar.o from the corresponding .c file.
objects = foo.o bar.o
$(objects): %.o: %.c
$(CC) -c $(CFLAGS) $< -o $@
In the previous example, $< is the automatic variable that holds the name of the dependency 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 nonmatching file
names (see
Functions for String Substitution and Analysis), as in the following example.
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.
The following 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.
0