f78
Catalogue of Implicit Rules
Contents|Index|Previous|Next
Catalogue of Implicit Rules
The following is a catalogue of predefined implicit rules which are always
available unless the makefile explicitly overrides or cancels them. See Canceling Implicit Rules for information on canceling or overriding an implicit rule.
The
-r or --no-builtin-rules options cancel all predefined rules.
Not all of these rules will always be defined, even when the
-r option is not given. Many of the predefined implicit rules are implemented
in make as suffix rules, so which ones will be defined depends on the suffix list (the list of dependencies of the special target, .SUFFIXES).
The default suffix list is:
.out, .a, .ln, .o, .c, .cc, .C, .p, .f, .F, .r, .y, .l, .s, .S, .mod, .sym, .def, .h, .info, .dvi, .tex, .texinfo, .texi, .txinfo, .w, .ch .web, .sh, .elc, .el.
All of the implicit rules (described in the following) whose dependencies have
one of these suffixes are actually suffix rules. If you modify the suffix
list, the only predefined suffix rules in effect will be those named by one or two
of the suffixes that are on the list you specify; rules whose suffixes fail to
be on the list are disabled.
See
Old-Fashioned Suffix Rules for full details on suffix rules.
Compiling C programs
n.o is made automatically from n.c with a command of the form, $(CC) -c $(CPPFLAGS) $(CFLAGS).
Compiling C++ programs
n.o is made automatically from n.cc orn.C with a command of the form, $(CXX) -c $(CPPFLAGS) $(CXXFLAGS). We encourage you to use the suffix .cc for C++ source files instead of .C.
Compiling Pascal programs
n.o is made automatically from n.p with the command of the form, $(PC) -c $(PFLAGS).
Compiling Fortran and Ratfor programs
n.o is made automatically from n.r, n.F orn.f by running the Fortran compiler. The precise command used is as follows:
.f
$(FC) -c $(FFLAGS).
.F
$(FC) -c $(FFLAGS) $(CPPFLAGS).
.r
$(FC) -c $(FFLAGS) $(RFLAGS).
Preprocessing Fortran and Ratfor programs
n.f is made automatically from n.r orn.F. This rule runs just the preprocessor to convert a Ratfor or preprocessable
Fortran program into a strict Fortran program. The precise command used is as
follows:
.F
$(FC) -F $(CPPFLAGS) $(FFLAGS)
.r
$(FC) -F $(FFLAGS) $(RFLAGS)
Compiling Modula-2 programs
n.sym is made from n.def with a command of the form:
$(M2C) $(M2FLAGS) $(DEFFLAGS)
n.o is made from n.mod; the form is:
$(M2C) $(M2FLAGS) $(MODFLAGS)
Assembling and preprocessing assembler programs
n.o is made automatically from n.s by running the assembler, as. The precise command is:
$(AS) $(ASFLAGS)
n.s is made automatically from n.S by running the C preprocessor, cpp. The precise command is:
$(CPP) $(CPPFLAGS)
Linking a single object file
n is made automatically from n.o by running the linker (usually called ld) via the C compiler. The precise command used is like the following examples
input.:
$(CC) $(LDFLAGS) n.o $(LOADLIBES)
This rule does the right thing for a simple program with only one source file.
It will also do the right thing if there are multiple object files (presumably
coming from various other source files), one of which has a name matching that
of the executable file.
Thus,
x: y.o z.o, when x.c, y.c and z.c all exist will execute the following.
cc -c x.c -o x.o
cc -c y.c -o y.o
cc -c z.c -o z.o
cc x.o y.o z.o -o x
rm -f x.o
rm -f y.o
rm -f z.o
In more complicated cases, such as when there is no object file whose name
derives from the executable file name, you must write an explicit command for
linking. Each kind of file automatically made into .o object files will be automatically linked by using the compiler ($(CC), $(FC) or $(PC); the C compiler, $(CC), is used to assemble .s files) without the -c option. This could be done by using the .o object files as intermediates, but it is faster to do the compiling and
linking in one step, so thats how its done.
Yacc for C programs
n.c is made automatically from n.y by running Yacc with the command:
$(YACC) $(YFLAGS)
Lex for C programs
n.c is made automatically from n.l by by running Lex. The actual command is:
$(LEX) $(LFLAGS)
Lex for Ratfor programs
n.r is made automatically from n.l by by running Lex. The actual command is:
$(LEX) $(LFLAGS)
The convention o
ffb
f using the same suffix .l for all Lex files regardless of whether they produce Ccode or Ratfor code
makes it impossible for make to determine automatically which of the two languages you are using in any
particular case. If make is called upon to remake an object file from a .l file, it must guess which compiler to use. It will guess the C compiler,
because that is more common. If you are using Ratfor, make sure make knows this
by mentioning n.r in the makefile. Or, if you are using Ratfor exclusively, with no C files,
remove .c from the list of implicit rule suffixes with the following:
.SUFFIXES:
.SUFFIXES: .o .r .f .l ...
Making Lint Libraries from C, Yacc, or Lex programs
n.ln is made from n.c by running lint. The precise command is shown in the following examples input.
$(LINT) $(LINTFLAGS) $(CPPFLAGS) -i
The same command is used on the C code produced from n.y or n.l.
TEX and Web
n.dvi is made from n.tex with the command $(TEX). n.tex is made from n.web with $(WEAVE), or from n.w (and from n.ch if it exists or can be made) with $(CWEAVE).
n.p is made from n.web with $(TANGLE) and n.c is made from n.w (and from n.ch if it exists or can
ffb
be made) with $(CTANGLE).
Texinfo and Info
To make
n.dvi from either n.texinfo, n.texi, or n.txinfo, use the command:
$(TEXI2DVI) $(TEXI2DVI_FLAGS)
To make n.info from either n.texinfo, n.texi, or n.txinfo, use the command in the form:
$(MAKEINFO) $(MAKEINFO_FLAGS)
RCS
Any file n is extracted if necessary from an RCS file named either n,v or RCS/n,v. The precise command used is the following.
$(CO) $(COFLAGS)
n will not be extracted from RCS if it already exists, even if the RCS file is
newer. The rules for RCS are terminal (see Match-Anything Pattern Rules), so RCS files cannot be generated from another source; they must actually
exist.
SCCS
Any file
n is extracted if necessary from an SCCS file named either s.n or SCCS/s.n. The precise command used is the following.
$(GET) $(GFLAGS)
The rules for SCCS are terminal (see Match-Anything Pattern Rules), so SCCS files cannot be generated from another source; they must actually
exist.
For the benefit of SCCS, a file
n is copied from n.sh and made executable (by everyone). This is for shell scripts that are
checked into SCCS. Since RCS preserves the execution permission of a file, you do not
need to use this feature with RCS.
We recommend that you avoid using of SCCS. RCS is widely held to be superior,
and is also free. By choosing free software in place of comparable
d09
(or
inferior) proprietary software, you support the free software movement.
Usually, you want to change only the variables listed in the catalogue of
implicit rules; the variables are documented in
Variables Used by Implicit Rules.
However, the commands in built-in implicit rules actually use variables such
as
COMPILE.c, LINK.p, and PREPROCESS.S, whose values contain the commands listed in the catalogue of implicit rules.
make follows the convention that the rule to compile a .x source file uses the variable COMPILE.x. Similarly, the rule to produce an executable from a .x file uses LINK.x; and the rule to preprocess a .x file uses PREPROCESS.x.
Every rule that produces an object file uses the variable,
OUTPUT_OPTION. make defines this variable either to contain -o $@ or to be empty, depending on a compile-time option. You need the -o option to ensure that the output goes into the right file when the source
file is in a different directory, as when using VPATH (see Searching Directories for Dependencies). However, compilers on some systems do not accept a -o switch for object files. If you use such a system, and use VPATH, some compilations will put their output in the wrong place. A possible
workaround for this problem is to give OUTPUT_OPTION the value:
; mv $*.o $@
0