make

unix v7是最后一个广泛发布的研究型UNIX版本

command takes four kinds of arguments:
macro definitions, flags, description file names, and target file names.
.DS
make [ flags ]  [ macro definitions ]  [ targets ]
.DE
The following summary of the operation of the command explains how these arguments are interpreted.
.PP
First, all macro definition arguments (arguments with embedded equal signs) are analyzed
and the assignments made.
Command-line macros override corresponding definitions found in the description files.
.PP
Next, the flag arguments are examined.
The permissible flags are
.IP \-i
Ignore error codes returned by invoked commands.
This mode is entered if the fake target name ``.IGNORE'' appears in the description file.
.IP \-s
Silent mode.  Do not print command lines before executing.
This mode is also entered if the fake target name ``.SILENT'' appears in the description file.
.IP \-r
Do not use the built-in rules.
.IP \-n
No execute mode.  Print commands, but do not execute them.
Even lines beginning with an ``@'' sign are printed.
.IP \-t
Touch the target files (causing them to be up to date) rather than issue the usual commands.
.IP \-q
Question.
The
.IT make
command returns a zero or non-zero status code depending on whether the target file
is or is not up to date.
.IP \-p
Print out the complete set of macro definitions and target descriptions
.IP \-d
Debug mode.  Print out detailed information on files and times examined.
.IP \-f
Description file name.  The next argument is assumed to be the name of a description file.
A file name of ``\-'' denotes the standard input.
If there are no ``\-f\|'' arguments, the file named
.IT makefile
or
.IT Makefile
in the current directory is read.
The contents of the description files override the built-in rules if they are present).
.PP
Finally, the remaining arguments are assumed to be the names of targets to be made;
they are done in left to right order.
If there are no such arguments, the first name in the description files that does not
begin with a period is ``made''.
.SH
Implicit Rules
.PP
The
.ul
make
program uses a table of interesting suffixes and a set
of transformation rules to supply default dependency
information and implied commands.
(The Appendix describes these tables and means of overriding
them.)
The default suffix list is:
.KS
.sp
.nf
.ta 0.5i 1.5i
	\fI.o\fR	Object file
	\fI.c\fR	C source file
	\fI.e\fR	Efl source file
	\fI.r\fR	Ratfor source file
	\fI.f\fR	Fortran source file
	\fI.s\fR	Assembler source file
	\fI.y\fR	Yacc-C source grammar
	\fI.yr\fR	Yacc-Ratfor source grammar
	\fI.ye\fR	Yacc-Efl source grammar
	\fI.l\fR	Lex source grammar
.fi
.sp
.KE
The following diagram summarizes the default transformation paths.
If there are two paths connecting a pair of suffixes, the longer
one is used only if the intermediate file exists or is
named in the description.
.KS
.sp
.ft I
.ta 2i
	.o
.sp 2
.ta 0.75i 1.25i 1.6i 2.1i
	.c	.r	.e	.f  .s  .y  .yr  .ye  .l  .d
.sp 2
.ta 0.6i 1.25i 1.6i
	.y .l	.yr	.ye
.ft R
.sp
.KE
.PP
If the file
.ul
x.o
were needed and there were an
.ul
x.c
in the description or directory, it would be compiled.
If there were also an
.IT x.l ,
that grammar would be run through Lex before compiling the result.
However, if there were no
.ul
x.c
but there were an
.IT x.l ,
.IT make
would discard the intermediate C-language file and use the
direct link in the graph above.
.PP
It is possible to change the names of some of the compilers used in the
default, or the flag arguments with which they are invoked by knowing
the macro names used.
The compiler names are the macros AS, CC, RC, EC, YACC, YACCR, YACCE, and LEX.
The command
.DS
make CC=newcc
.DE
will cause the ``newcc'' command to be used instead of the
usual C compiler.
The macros CFLAGS, RFLAGS, EFLAGS, YFLAGS, and LFLAGS may be set to
cause these commands to be issued with optional flags.
Thus,
.DS
make "CFLAGS=\|\(miO"
.DE
causes the optimizing C compiler to be used.
.SH
Example
.PP
As an example of the use of
.ul
make,
we will present the description file used to maintain
the
.ul
make
command itself.
The code for
.ul
make
is spread over a number of C source files and a Yacc grammar.
The description file contains:
.DS
# Description file for the Make command
.sp .3
P = und \-3 | opr \-r2       # send to GCOS to be printed
FILES = Makefile version.c defs main.c doname.c misc.c files.c dosys.c\
	gram.y lex.c gcos.c
OBJECTS = version.o main.o doname.o misc.o files.o dosys.o gram.o
LIBES= \-lS
LINT = lint \-p
CFLAGS = \-O
.sp .3
make:  $(OBJECTS)
	cc $(CFLAGS) $(OBJECTS) $(LIBES) \-o make
	size make
.sp .3
$(OBJECTS):  defs
gram.o: lex.c
.sp .3
cleanup:
	-rm *.o gram.c
	-du
.sp .3
install:
	@size make /usr/bin/make
	cp make /usr/bin/make ; rm make
.sp .3
print:  $(FILES)	# print recently changed files
	pr $? | $P
	touch print
.sp .3
test:
	make \-dp | grep \-v TIME >1zap
	/usr/bin/make \-dp | grep \-v TIME >2zap
	diff 1zap 2zap
	rm 1zap 2zap
.sp .3
lint :  dosys.c doname.c files.c main.c misc.c version.c gram.c
	$(LINT) dosys.c doname.c files.c main.c misc.c version.c gram.c
	rm gram.c
.sp .3
arch:
	ar uv /sys/source/s2/make.a $(FILES)
.DE
.IT Make
usually prints out each command before issuing it.
The following output results from typing the simple command
.DS
make
.DE
in a directory containing only the source and description file:
.DS
 cc  \-c version.c
 cc  \-c main.c
 cc  \-c doname.c
 cc  \-c misc.c
 cc  \-c files.c
 cc  \-c dosys.c
 yacc  gram.y
 mv y.tab.c gram.c
 cc  \-c gram.c
 cc  version.o main.o doname.o misc.o files.o dosys.o gram.o \-lS \-o make
 13188+3348+3044 = 19580b = 046174b
.DE
Although none of the source files or grammars were mentioned
by name in the description file,
.IT make
found them using its suffix rules and issued the needed commands.
The string of digits results from the ``size make''
command; the printing of the command line itself was
suppressed by an @ sign.
The @ sign on the
.IT size
command in the description file suppressed the printing of the command,
so only the sizes are written.
.PP
The last few entries in the description file are useful maintenance sequences.
The ``print'' entry prints only the files that have been changed since the last
``make print'' command.
A zero-length file
.IT print
is maintained to keep track of the time of the printing;
the $? macro in the command line then picks up only the names of the files
changed since
.IT print
was touched.
The printed output can be sent to a different printer or to a file by changing the definition of the
.IT P
macro:
.DS
make print "P = opr \-sp"
	\fIor\fR
make print "P=  cat >zap"
.DE
.SH
Suggestions and Warnings
.PP
The most common difficulties arise from
.IT make 's
specific meaning of dependency.
If file
.IT x.c
has a ``#include "defs"''
line, then the object file
.IT x.o
depends on
.IT defs ;
the source file
.IT x.c
does not.
(If
.IT defs
is changed, it is not necessary to do anything
to the file
.IT x.c ,
while it is necessary to recreate
.IT x.o .)
.PP
To discover what
.IT make
would do, the ``\-n'' option is very useful.
The command
.DS
make \-n
.DE
orders
.IT make
to print out the commands it would issue without actually taking the time to execute them.
If a change to a file is absolutely certain to be benign
(e.g., adding a new definition to an include file),
the ``\-t'' (touch) option
can save a lot of time:
instead of issuing a large number of superfluous recompilations,
.IT make
updates the modification times on the affected file.
Thus, the command
.DS
make \-ts
.DE
(``touch silently'') causes the relevant files to appear up to date.
Obvious care is necessary, since this mode of operation subverts
the intention of
.IT make
and destroys all memory of the previous relationships.
.PP
The debugging flag (``\-d'') causes
.IT make
to print out a very detailed description of what it is doing, including the
file times.  The output is verbose, and recommended only as a last resort.
.SH
Acknowledgments
.PP
I would like to thank S. C. Johnson for suggesting this approach
to program maintenance control.
I would like to thank S. C. Johnson and H. Gajewska for being
the prime guinea pigs during development of
.IT make .
.SH
References
.IP 1.
S. C. Johnson,
``Yacc \(em Yet Another Compiler-Compiler'',
Bell Laboratories
Computing Science Technical Report #32,
July 1978.
.IP 2.
M. E. Lesk,
``Lex \(em A Lexical Analyzer Generator'',
Computing Science Technical Report #39,
October 1975.
.bp
.SH
Appendix.  Suffixes and Transformation Rules
.PP
The
.ul
make
program itself does not know what file name suffixes are interesting
or how to transform a file with one suffix into a file with another
suffix.
This information is stored in an internal table that has the form of a description file.
If the ``\-r'' flag is used, this table is not used.
.PP
The list of suffixes is actually the dependency list for the name
``.SUFFIXES'';
.ul
make
looks for a file with any of the suffixes on the list.
If such a file exists, and if there is a transformation
rule for that combination,
.ul
make
acts as described earlier.
The transformation rule names are the concatenation of the
two suffixes.
The name of the rule to transform a ``\fI.r\fR'' file to a ``\fI.o\fR'' file
is thus ``\fI.r.o\fR''.
If the rule is present and no explicit command sequence
has been given in the user's description files, the command
sequence for the rule ``.r.o'' is used.
If a command is generated by using one of these suffixing rules,
the macro $\(** is given the value of the stem
(everything but the suffix) of the name of the file to be made,
and the macro $< is the name of the dependent that caused the action.
.PP
The order of the suffix list is significant, since it is scanned from
left to right, and the first name that is formed that has both a file
and a rule associated with it is used.
If new names are to be appended, the user can just add an entry for
``.SUFFIXES'' in his own description file; the dependents will be added to the usual list.
A ``.SUFFIXES'' line without any dependents deletes the current list.
(It is necessary to clear the current list if the order of names is to be changed).
.PP
The following is an excerpt from the default rules file:
.DS
.ta .5i 1i
 .SUFFIXES : .o .c .e .r .f .y .yr .ye .l .s
 YACC=yacc
 YACCR=yacc \-r
 YACCE=yacc \-e
 YFLAGS=
 LEX=lex
 LFLAGS=
 CC=cc
 AS=as \-
 CFLAGS=
 RC=ec
 RFLAGS=
 EC=ec
 EFLAGS=
 FFLAGS=
 .c.o :
 	$(CC) $(CFLAGS) \-c $<
 .e.o .r.o .f.o :
 	$(EC) $(RFLAGS) $(EFLAGS) $(FFLAGS) \-c $<
 .s.o :
 	$(AS) \-o $@ $<
 .y.o :
 	$(YACC) $(YFLAGS) $<
 	$(CC) $(CFLAGS) \-c y.tab.c
 	rm y.tab.c
 	mv y.tab.o $@
 .y.c :
 	$(YACC) $(YFLAGS) $<
 	mv y.tab.c $@
.DE