File: make.info,  Node: Pattern Match,  Next: Match-Anything Rules,  Prev: Automatic Variables,  Up: Pattern Rules

10.5.4 How Patterns Match
-------------------------

A target pattern is composed of a '%' between a prefix and a suffix,
either or both of which may be empty.  The pattern matches a file name
only if the file name starts with the prefix and ends with the suffix,
without overlap.  The text between the prefix and the suffix is called
the "stem".  Thus, when the pattern '%.o' matches the file name
'test.o', the stem is 'test'.  The pattern rule prerequisites are turned
into actual file names by substituting the stem for the character '%'.
Thus, if in the same example one of the prerequisites is written as
'%.c', it expands to 'test.c'.

   When the target pattern does not contain a slash (and it usually does
not), directory names in the file names are removed from the file name
before it is compared with the target prefix and suffix.  After the
comparison of the file name to the target pattern, the directory names,
along with the slash that ends them, are added on to the prerequisite
file names generated from the pattern rule's prerequisite patterns and
the file name.  The directories are ignored only for the purpose of
finding an implicit rule to use, not in the application of that rule.
Thus, 'e%t' matches the file name 'src/eat', with 'src/a' as the stem.
When prerequisites are turned into file names, the directories from the
stem are added at the front, while the rest of the stem is substituted
for the '%'.  The stem 'src/a' with a prerequisite pattern 'c%r' gives
the file name 'src/car'.

   A pattern rule can be used to build a given file only if there is a
target pattern that matches the file name, _and_ all prerequisites in
that rule either exist or can be built.  The rules you write take
precedence over those that are built in.  Note however, that a rule
which can be satisfied without chaining other implicit rules (for
example, one which has no prerequisites or its prerequisites already
exist or are mentioned) always takes priority over a rule with
prerequisites that must be made by chaining other implicit rules.

   It is possible that more than one pattern rule will meet these
criteria.  In that case, 'make' will choose the rule with the shortest
stem (that is, the pattern that matches most specifically).  If more
than one pattern rule has the shortest stem, 'make' will choose the
first one found in the makefile.

   This algorithm results in more specific rules being preferred over
more generic ones; for example:

     %.o: %.c
             $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@

     %.o : %.f
             $(COMPILE.F) $(OUTPUT_OPTION) $<

     lib/%.o: lib/%.c
             $(CC) -fPIC -c $(CFLAGS) $(CPPFLAGS) $< -o $@

   Given these rules and asked to build 'bar.o' where both 'bar.c' and
'bar.f' exist, 'make' will choose the first rule and compile 'bar.c'
into 'bar.o'.  In the same situation where 'bar.c' does not exist, then
'make' will choose the second rule and compile 'bar.f' into 'bar.o'.

   If 'make' is asked to build 'lib/bar.o' and both 'lib/bar.c' and
'lib/bar.f' exist, then the third rule will be chosen since the stem for
this rule ('bar') is shorter than the stem for the first rule
('lib/bar').  If 'lib/bar.c' does not exist then the third rule is not
eligible and the second rule will be used, even though the stem is
longer.