Often, for ease of use, you want to capture a useful set of shell
commands in a Makefile
, yet the commands do not generate a file
and thus have no target file; the target is just a
convenient handle for a command that you want to run periodically. The
clean
target from example 5.2 is an
example of such a rule, repeated here:
clean: rm -f $(m4_OBJECTS)
Example 5.26: A phony target
There is no file clean
involved here; but you can clean
out the object files in the build directory with:
$ make clean rm -f main.o freeze.o stackovf.o
There is nothing special happening here. Asking Make to build the
clean
target, it finds that the clean
file is out of date
(missing entirely, infact!) and tries to refresh it by running
the commands in the associated rule. No clean
file is
created by running commands, which means that Make will consider
the clean
target to still be out of date the next time you invoke
make clean
.
So what happens if you accidentally drop a file named clean
into
the build directory, and try to invoke the clean
target? Well,
Make will see the file, and find that there are no dependencies
against the clean
target - so clean
is up to date
already, and there is no need to execute the rm
command. In
all fairness, if you choose the names of your phony targets carefully,
you shouldn't get into this situation. Just the same, Make provides a
special target, .PHONY, against which you can list your phony
targets as dependencies, like this:
.PHONY: clean
Make now knows that clean
does not represent an actual file,
and will always execute the command part of the clean
rule.
Unlike normal targets, .PHONY
can be inserted into a Makefile
more than once, in which case Make will append subsequent .PHONY
dependencies to the current list, in exactly the same way that
.SUFFIXES
behaves (voir Suffix Rules).