f78
How Makefiles Are Remade
Contents|Index|Previous|Next
How Makefiles Are Remade
Sometimes makefiles can be remade from other files, such as RCS or SCCS files.
If a makefile can be remade from other files, you probably want make to get an up-to-date version of the makefile to read in.
To this end, after reading in all makefiles,
make will consider each as a goal target and attempt to update it. If a makefile
has a rule which says how to update it (found either in that very makefile or in
another one) or if an implicit rule applies to it (see Using Implicit Rules), it will be updated if necessary. After all makefiles have been checked, if
any have actually been changed, make starts with a clean slate and reads all the makefiles over again. (It will
also attempt to update each of them over again, but normally this will not change
them again, since they are already up to date.)
If the makefiles specify a double-colon rule to remake a file with commands
but no dependencies, that file will always be remade (see
Double-Colon Rules). In the case of makefiles, a make-file that has a double-colon rule with
commands but no dependencies will be remade every time make is run, and then again
after make starts over and reads the makefiles in again. This would cause an
infinite loop; make would constantly remake the makefile, and never do anything
else. So, to avoid this, make will not attempt to remake makefiles which are
specified as double-colon targets but have no dependencies.
If you do not specify any makefiles to be read with
-f or --file options, make will try the default makefile names; see What Name to Give Your Makefile. Unlike makefiles explicitly requested with -f or--file options, make is not certain that these makefiles should exist. However, if
a default makefile does not exist but can be created by running make rules, you
probably want the rules to be run so that the makefile can be used.
Therefore, if none of the default makefiles exists, make will try to make each
of them in the same order in which they are searched for (
What Name to Give Your Makefile) until it succeeds in making one, or it runs out of names to try. Note that
it is not an error if make cannot find or make any makefile
a4c
; a makefile is not
always necessary.
When you use the
-t or --touch option (see Instead of Executing the Commands), you would not want to use an out-of-date makefile to decide which targets
to touch. So the -t option has no effect on updating makefiles; they are really updated even if -t is specified. Likewise, -q (or --question) and -n (or --just-print) do not prevent updating of makefiles, because an out-of-date makefile would
result in the wrong output for other targets.
However, on occasion you might actually wish to prevent updating of even the
makefiles. You can do this by specifying the makefiles as goals in the command
line as well as specifying them as makefiles. When the makefile name is
specified explicitly as a goal, the options
-t and so on do apply to them.
Thus,
make -f mfile -n foo will update mfile, read it in, and then print the commands to update foo and its dependencies without running them. The commands printed for foo will be those specified in the updated contents of mfile.
0