manpagez: man pages & more
info make
Home | html | info | man

File: make.info,  Node: Using Implicit,  Next: Catalogue of Rules,  Prev: Implicit_Rules.php">Implicit Rules,  Up: Implicit_Rules.php">Implicit Rules

10.1 Using Implicit Rules
=========================

To allow 'make' to find a customary method for updating a target file,
all you have to do is refrain from specifying recipes yourself.  Either
write a rule with no recipe, or don't write a rule at all.  Then 'make'
will figure out which implicit rule to use based on which kind of source
file exists or can be made.

   For example, suppose the makefile looks like this:

     foo : foo.o bar.o
             cc -o foo foo.o bar.o $(CFLAGS) $(LDFLAGS)

Because you mention 'foo.o' but do not give a rule for it, 'make' will
automatically look for an implicit rule that tells how to update it.
This happens whether or not the file 'foo.o' currently exists.

   If an implicit rule is found, it can supply both a recipe and one or
more prerequisites (the source files).  You would want to write a rule
for 'foo.o' with no recipe if you need to specify additional
prerequisites, such as header files, that the implicit rule cannot
supply.

   Each implicit rule has a target pattern and prerequisite patterns.
There may be many implicit rules with the same target pattern.  For
example, numerous rules make '.o' files: one, from a '.c' file with the
C compiler; another, from a '.p' file with the Pascal compiler; and so
on.  The rule that actually applies is the one whose prerequisites exist
or can be made.  So, if you have a file 'foo.c', 'make' will run the C
compiler; otherwise, if you have a file 'foo.p', 'make' will run the
Pascal compiler; and so on.

   Of course, when you write the makefile, you know which implicit rule
you want 'make' to use, and you know it will choose that one because you
know which possible prerequisite files are supposed to exist.  *Note
Catalogue of Built-In Rules: Catalogue of Rules, for a catalogue of all
the predefined implicit rules.

   Above, we said an implicit rule applies if the required prerequisites
"exist or can be made".  A file "can be made" if it is mentioned
explicitly in the makefile as a target or a prerequisite, or if an
implicit rule can be recursively found for how to make it.  When an
implicit prerequisite is the result of another implicit rule, we say
that "chaining" is occurring.  *Note Chains of Implicit Rules: Chained
Rules.

   In general, 'make' searches for an implicit rule for each target, and
for each double-colon rule, that has no recipe.  A file that is
mentioned only as a prerequisite is considered a target whose rule
specifies nothing, so implicit rule search happens for it.  *Note
Implicit Rule Search Algorithm: Implicit Rule Search, for the details of
how the search is done.

   Note that explicit prerequisites do not influence implicit rule
search.  For example, consider this explicit rule:

     foo.o: foo.p

The prerequisite on 'foo.p' does not necessarily mean that 'make' will
remake 'foo.o' according to the implicit rule to make an object file, a
'.o' file, from a Pascal source file, a '.p' file.  For example, if
'foo.c' also exists, the implicit rule to make an object file from a C
source file is used instead, because it appears before the Pascal rule
in the list of predefined implicit rules (*note Catalogue of Built-In
Rules: Catalogue of Rules.).

   If you do not want an implicit rule to be used for a target that has
no recipe, you can give that target an empty recipe by writing a
semicolon (*note Defining Empty Recipes: Empty Recipes.).

© manpagez.com 2000-2024
Individual documents may contain additional copyright information.