1 This is make.info, produced by makeinfo version 4.13 from make.texi.
3 This file documents the GNU `make' utility, which determines
4 automatically which pieces of a large program need to be recompiled,
5 and issues the commands to recompile them.
7 This is Edition 0.72, last updated 9 October 2013, of `The GNU Make
8 Manual', for GNU `make' version 4.0.
10 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
11 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
12 2010, 2011, 2012, 2013 Free Software Foundation, Inc.
14 Permission is granted to copy, distribute and/or modify this
15 document under the terms of the GNU Free Documentation License,
16 Version 1.3 or any later version published by the Free Software
17 Foundation; with no Invariant Sections, with the Front-Cover Texts
18 being "A GNU Manual," and with the Back-Cover Texts as in (a)
19 below. A copy of the license is included in the section entitled
20 "GNU Free Documentation License."
22 (a) The FSF's Back-Cover Text is: "You have the freedom to copy and
23 modify this GNU manual. Buying copies from the FSF supports it in
24 developing GNU and promoting software freedom."
26 INFO-DIR-SECTION Software development
28 * Make: (make). Remake files automatically.
32 File: make.info, Node: Options Summary, Prev: Testing, Up: Running
34 9.7 Summary of Options
35 ======================
37 Here is a table of all the options `make' understands:
41 These options are ignored for compatibility with other versions of
46 Consider all targets out-of-date. GNU `make' proceeds to consider
47 targets and their prerequisites using the normal algorithms;
48 however, all targets so considered are always remade regardless of
49 the status of their prerequisites. To avoid infinite recursion, if
50 `MAKE_RESTARTS' (*note Other Special Variables: Special
51 Variables.) is set to a number greater than 0 this option is
52 disabled when considering whether to remake makefiles (*note How
53 Makefiles Are Remade: Remaking Makefiles.).
57 Change to directory DIR before reading the makefiles. If multiple
58 `-C' options are specified, each is interpreted relative to the
59 previous one: `-C / -C etc' is equivalent to `-C /etc'. This is
60 typically used with recursive invocations of `make' (*note
61 Recursive Use of `make': Recursion.).
64 Print debugging information in addition to normal processing. The
65 debugging information says which files are being considered for
66 remaking, which file-times are being compared and with what
67 results, which files actually need to be remade, which implicit
68 rules are considered and which are applied--everything interesting
69 about how `make' decides what to do. The `-d' option is
70 equivalent to `--debug=a' (see below).
73 Print debugging information in addition to normal processing.
74 Various levels and types of output can be chosen. With no
75 arguments, print the "basic" level of debugging. Possible
76 arguments are below; only the first character is considered, and
77 values must be comma- or space-separated.
80 All types of debugging output are enabled. This is
81 equivalent to using `-d'.
84 Basic debugging prints each target that was found to be
85 out-of-date, and whether the build was successful or not.
88 A level above `basic'; includes messages about which
89 makefiles were parsed, prerequisites that did not need to be
90 rebuilt, etc. This option also enables `basic' messages.
93 Prints messages describing the implicit rule searches for
94 each target. This option also enables `basic' messages.
97 Prints messages giving details on the invocation of specific
101 By default, the above messages are not enabled while trying
102 to remake the makefiles. This option enables messages while
103 rebuilding makefiles, too. Note that the `all' option does
104 enable this option. This option also enables `basic'
108 Disable all debugging currently enabled. If additional
109 debugging flags are encountered after this they will still
113 `--environment-overrides'
114 Give variables taken from the environment precedence over
115 variables from makefiles. *Note Variables from the Environment:
119 Evaluate STRING as makefile syntax. This is a command-line
120 version of the `eval' function (*note Eval Function::). The
121 evaluation is performed after the default rules and variables have
122 been defined, but before any makefiles are read.
127 Read the file named FILE as a makefile. *Note Writing Makefiles:
132 Remind you of the options that `make' understands and then exit.
136 Ignore all errors in recipes executed to remake files. *Note
137 Errors in Recipes: Errors.
141 Specifies a directory DIR to search for included makefiles. *Note
142 Including Other Makefiles: Include. If several `-I' options are
143 used to specify several directories, the directories are searched
144 in the order specified.
148 Specifies the number of recipes (jobs) to run simultaneously.
149 With no argument, `make' runs as many recipes simultaneously as
150 possible. If there is more than one `-j' option, the last one is
151 effective. *Note Parallel Execution: Parallel, for more
152 information on how recipes are run. Note that this option is
157 Continue as much as possible after an error. While the target that
158 failed, and those that depend on it, cannot be remade, the other
159 prerequisites of these targets can be processed all the same.
160 *Note Testing the Compilation of a Program: Testing.
163 `--load-average[=LOAD]'
165 Specifies that no new recipes should be started if there are other
166 recipes running and the load average is at least LOAD (a
167 floating-point number). With no argument, removes a previous load
168 limit. *Note Parallel Execution: Parallel.
171 `--check-symlink-times'
172 On systems that support symbolic links, this option causes `make'
173 to consider the timestamps on any symbolic links in addition to the
174 timestamp on the file referenced by those links. When this option
175 is provided, the most recent timestamp among the file and the
176 symbolic links is taken as the modification time for this target
183 Print the recipe that would be executed, but do not execute it
184 (except in certain circumstances). *Note Instead of Executing
185 Recipes: Instead of Execution.
190 Do not remake the file FILE even if it is older than its
191 prerequisites, and do not remake anything on account of changes in
192 FILE. Essentially the file is treated as very old and its rules
193 are ignored. *Note Avoiding Recompilation of Some Files: Avoiding
197 `--output-sync[=TYPE]'
198 Ensure that the complete output from each recipe is printed in one
199 uninterrupted sequence. This option is only useful when using the
200 `--jobs' option to run multiple recipes simultaneously (*note
201 Parallel Execution: Parallel.) Without this option output will be
202 displayed as it is generated by the recipes.
204 With no type or the type `target', output from the entire recipe
205 of each target is grouped together. With the type `line', output
206 from each line in the recipe is grouped together. With the type
207 `recurse', the output from an entire recursive make is grouped
208 together. With the type `none', no output synchronization is
209 performed. *Note Output During Parallel Execution: Parallel
214 Print the data base (rules and variable values) that results from
215 reading the makefiles; then execute as usual or as otherwise
216 specified. This also prints the version information given by the
217 `-v' switch (see below). To print the data base without trying to
218 remake any files, use `make -qp'. To print the data base of
219 predefined rules and variables, use `make -p -f /dev/null'. The
220 data base output contains file name and line number information for
221 recipe and variable definitions, so it can be a useful debugging
222 tool in complex environments.
226 "Question mode". Do not run any recipes, or print anything; just
227 return an exit status that is zero if the specified targets are
228 already up to date, one if any remaking is required, or two if an
229 error is encountered. *Note Instead of Executing Recipes: Instead
234 Eliminate use of the built-in implicit rules (*note Using Implicit
235 Rules: Implicit Rules.). You can still define your own by writing
236 pattern rules (*note Defining and Redefining Pattern Rules:
237 Pattern Rules.). The `-r' option also clears out the default list
238 of suffixes for suffix rules (*note Old-Fashioned Suffix Rules:
239 Suffix Rules.). But you can still define your own suffixes with a
240 rule for `.SUFFIXES', and then define your own suffix rules. Note
241 that only _rules_ are affected by the `-r' option; default
242 variables remain in effect (*note Variables Used by Implicit
243 Rules: Implicit Variables.); see the `-R' option below.
246 `--no-builtin-variables'
247 Eliminate use of the built-in rule-specific variables (*note
248 Variables Used by Implicit Rules: Implicit Variables.). You can
249 still define your own, of course. The `-R' option also
250 automatically enables the `-r' option (see above), since it
251 doesn't make sense to have implicit rules without any definitions
252 for the variables that they use.
257 Silent operation; do not print the recipes as they are executed.
258 *Note Recipe Echoing: Echoing.
263 Cancel the effect of the `-k' option. This is never necessary
264 except in a recursive `make' where `-k' might be inherited from
265 the top-level `make' via `MAKEFLAGS' (*note Recursive Use of
266 `make': Recursion.) or if you set `-k' in `MAKEFLAGS' in your
271 Touch files (mark them up to date without really changing them)
272 instead of running their recipes. This is used to pretend that the
273 recipes were done, in order to fool future invocations of `make'.
274 *Note Instead of Executing Recipes: Instead of Execution.
277 Show tracing information for `make' execution. Prints the entire
278 recipe to be executed, even for recipes that are normally silent
279 (due to `.SILENT' or `@'). Also prints the makefile name and line
280 number where the recipe was defined, and information on why the
281 target is being rebuilt.
285 Print the version of the `make' program plus a copyright, a list
286 of authors, and a notice that there is no warranty; then exit.
290 Print a message containing the working directory both before and
291 after executing the makefile. This may be useful for tracking
292 down errors from complicated nests of recursive `make' commands.
293 *Note Recursive Use of `make': Recursion. (In practice, you
294 rarely need to specify this option since `make' does it for you;
295 see *note The `--print-directory' Option: -w Option.)
297 `--no-print-directory'
298 Disable printing of the working directory under `-w'. This option
299 is useful when `-w' is turned on automatically, but you do not
300 want to see the extra messages. *Note The `--print-directory'
307 Pretend that the target FILE has just been modified. When used
308 with the `-n' flag, this shows you what would happen if you were
309 to modify that file. Without `-n', it is almost the same as
310 running a `touch' command on the given file before running `make',
311 except that the modification time is changed only in the
312 imagination of `make'. *Note Instead of Executing Recipes:
313 Instead of Execution.
315 `--warn-undefined-variables'
316 Issue a warning message whenever `make' sees a reference to an
317 undefined variable. This can be helpful when you are trying to
318 debug makefiles which use variables in complex ways.
321 File: make.info, Node: Implicit Rules, Next: Archives, Prev: Running, Up: Top
323 10 Using Implicit Rules
324 ***********************
326 Certain standard ways of remaking target files are used very often. For
327 example, one customary way to make an object file is from a C source
328 file using the C compiler, `cc'.
330 "Implicit rules" tell `make' how to use customary techniques so that
331 you do not have to specify them in detail when you want to use them.
332 For example, there is an implicit rule for C compilation. File names
333 determine which implicit rules are run. For example, C compilation
334 typically takes a `.c' file and makes a `.o' file. So `make' applies
335 the implicit rule for C compilation when it sees this combination of
338 A chain of implicit rules can apply in sequence; for example, `make'
339 will remake a `.o' file from a `.y' file by way of a `.c' file.
341 The built-in implicit rules use several variables in their recipes so
342 that, by changing the values of the variables, you can change the way
343 the implicit rule works. For example, the variable `CFLAGS' controls
344 the flags given to the C compiler by the implicit rule for C
347 You can define your own implicit rules by writing "pattern rules".
349 "Suffix rules" are a more limited way to define implicit rules.
350 Pattern rules are more general and clearer, but suffix rules are
351 retained for compatibility.
355 * Using Implicit:: How to use an existing implicit rule
356 to get the recipes for updating a file.
357 * Catalogue of Rules:: A list of built-in implicit rules.
358 * Implicit Variables:: How to change what predefined rules do.
359 * Chained Rules:: How to use a chain of implicit rules.
360 * Pattern Rules:: How to define new implicit rules.
361 * Last Resort:: How to define a recipe for rules which
363 * Suffix Rules:: The old-fashioned style of implicit rule.
364 * Implicit Rule Search:: The precise algorithm for applying
368 File: make.info, Node: Using Implicit, Next: Catalogue of Rules, Prev: Implicit Rules, Up: Implicit Rules
370 10.1 Using Implicit Rules
371 =========================
373 To allow `make' to find a customary method for updating a target file,
374 all you have to do is refrain from specifying recipes yourself. Either
375 write a rule with no recipe, or don't write a rule at all. Then `make'
376 will figure out which implicit rule to use based on which kind of
377 source file exists or can be made.
379 For example, suppose the makefile looks like this:
382 cc -o foo foo.o bar.o $(CFLAGS) $(LDFLAGS)
384 Because you mention `foo.o' but do not give a rule for it, `make' will
385 automatically look for an implicit rule that tells how to update it.
386 This happens whether or not the file `foo.o' currently exists.
388 If an implicit rule is found, it can supply both a recipe and one or
389 more prerequisites (the source files). You would want to write a rule
390 for `foo.o' with no recipe if you need to specify additional
391 prerequisites, such as header files, that the implicit rule cannot
394 Each implicit rule has a target pattern and prerequisite patterns.
395 There may be many implicit rules with the same target pattern. For
396 example, numerous rules make `.o' files: one, from a `.c' file with the
397 C compiler; another, from a `.p' file with the Pascal compiler; and so
398 on. The rule that actually applies is the one whose prerequisites
399 exist or can be made. So, if you have a file `foo.c', `make' will run
400 the C compiler; otherwise, if you have a file `foo.p', `make' will run
401 the Pascal compiler; and so on.
403 Of course, when you write the makefile, you know which implicit rule
404 you want `make' to use, and you know it will choose that one because you
405 know which possible prerequisite files are supposed to exist. *Note
406 Catalogue of Implicit Rules: Catalogue of Rules, for a catalogue of all
407 the predefined implicit rules.
409 Above, we said an implicit rule applies if the required
410 prerequisites "exist or can be made". A file "can be made" if it is
411 mentioned explicitly in the makefile as a target or a prerequisite, or
412 if an implicit rule can be recursively found for how to make it. When
413 an implicit prerequisite is the result of another implicit rule, we say
414 that "chaining" is occurring. *Note Chains of Implicit Rules: Chained
417 In general, `make' searches for an implicit rule for each target, and
418 for each double-colon rule, that has no recipe. A file that is
419 mentioned only as a prerequisite is considered a target whose rule
420 specifies nothing, so implicit rule search happens for it. *Note
421 Implicit Rule Search Algorithm: Implicit Rule Search, for the details
422 of how the search is done.
424 Note that explicit prerequisites do not influence implicit rule
425 search. For example, consider this explicit rule:
429 The prerequisite on `foo.p' does not necessarily mean that `make' will
430 remake `foo.o' according to the implicit rule to make an object file, a
431 `.o' file, from a Pascal source file, a `.p' file. For example, if
432 `foo.c' also exists, the implicit rule to make an object file from a C
433 source file is used instead, because it appears before the Pascal rule
434 in the list of predefined implicit rules (*note Catalogue of Implicit
435 Rules: Catalogue of Rules.).
437 If you do not want an implicit rule to be used for a target that has
438 no recipe, you can give that target an empty recipe by writing a
439 semicolon (*note Defining Empty Recipes: Empty Recipes.).
442 File: make.info, Node: Catalogue of Rules, Next: Implicit Variables, Prev: Using Implicit, Up: Implicit Rules
444 10.2 Catalogue of Implicit Rules
445 ================================
447 Here is a catalogue of predefined implicit rules which are always
448 available unless the makefile explicitly overrides or cancels them.
449 *Note Canceling Implicit Rules: Canceling Rules, for information on
450 canceling or overriding an implicit rule. The `-r' or
451 `--no-builtin-rules' option cancels all predefined rules.
453 This manual only documents the default rules available on POSIX-based
454 operating systems. Other operating systems, such as VMS, Windows,
455 OS/2, etc. may have different sets of default rules. To see the full
456 list of default rules and variables available in your version of GNU
457 `make', run `make -p' in a directory with no makefile.
459 Not all of these rules will always be defined, even when the `-r'
460 option is not given. Many of the predefined implicit rules are
461 implemented in `make' as suffix rules, so which ones will be defined
462 depends on the "suffix list" (the list of prerequisites of the special
463 target `.SUFFIXES'). The default suffix list is: `.out', `.a', `.ln',
464 `.o', `.c', `.cc', `.C', `.cpp', `.p', `.f', `.F', `.m', `.r', `.y',
465 `.l', `.ym', `.lm', `.s', `.S', `.mod', `.sym', `.def', `.h', `.info',
466 `.dvi', `.tex', `.texinfo', `.texi', `.txinfo', `.w', `.ch' `.web',
467 `.sh', `.elc', `.el'. All of the implicit rules described below whose
468 prerequisites have one of these suffixes are actually suffix rules. If
469 you modify the suffix list, the only predefined suffix rules in effect
470 will be those named by one or two of the suffixes that are on the list
471 you specify; rules whose suffixes fail to be on the list are disabled.
472 *Note Old-Fashioned Suffix Rules: Suffix Rules, for full details on
476 `N.o' is made automatically from `N.c' with a recipe of the form
477 `$(CC) $(CPPFLAGS) $(CFLAGS) -c'.
479 Compiling C++ programs
480 `N.o' is made automatically from `N.cc', `N.cpp', or `N.C' with a
481 recipe of the form `$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c'. We
482 encourage you to use the suffix `.cc' for C++ source files instead
485 Compiling Pascal programs
486 `N.o' is made automatically from `N.p' with the recipe `$(PC)
489 Compiling Fortran and Ratfor programs
490 `N.o' is made automatically from `N.r', `N.F' or `N.f' by running
491 the Fortran compiler. The precise recipe used is as follows:
494 `$(FC) $(FFLAGS) -c'.
497 `$(FC) $(FFLAGS) $(CPPFLAGS) -c'.
500 `$(FC) $(FFLAGS) $(RFLAGS) -c'.
502 Preprocessing Fortran and Ratfor programs
503 `N.f' is made automatically from `N.r' or `N.F'. This rule runs
504 just the preprocessor to convert a Ratfor or preprocessable
505 Fortran program into a strict Fortran program. The precise recipe
509 `$(FC) $(CPPFLAGS) $(FFLAGS) -F'.
512 `$(FC) $(FFLAGS) $(RFLAGS) -F'.
514 Compiling Modula-2 programs
515 `N.sym' is made from `N.def' with a recipe of the form `$(M2C)
516 $(M2FLAGS) $(DEFFLAGS)'. `N.o' is made from `N.mod'; the form is:
517 `$(M2C) $(M2FLAGS) $(MODFLAGS)'.
519 Assembling and preprocessing assembler programs
520 `N.o' is made automatically from `N.s' by running the assembler,
521 `as'. The precise recipe is `$(AS) $(ASFLAGS)'.
523 `N.s' is made automatically from `N.S' by running the C
524 preprocessor, `cpp'. The precise recipe is `$(CPP) $(CPPFLAGS)'.
526 Linking a single object file
527 `N' is made automatically from `N.o' by running the linker
528 (usually called `ld') via the C compiler. The precise recipe used
529 is `$(CC) $(LDFLAGS) N.o $(LOADLIBES) $(LDLIBS)'.
531 This rule does the right thing for a simple program with only one
532 source file. It will also do the right thing if there are multiple
533 object files (presumably coming from various other source files),
534 one of which has a name matching that of the executable file.
539 when `x.c', `y.c' and `z.c' all exist will execute:
549 In more complicated cases, such as when there is no object file
550 whose name derives from the executable file name, you must write
551 an explicit recipe for linking.
553 Each kind of file automatically made into `.o' object files will
554 be automatically linked by using the compiler (`$(CC)', `$(FC)' or
555 `$(PC)'; the C compiler `$(CC)' is used to assemble `.s' files)
556 without the `-c' option. This could be done by using the `.o'
557 object files as intermediates, but it is faster to do the
558 compiling and linking in one step, so that's how it's done.
561 `N.c' is made automatically from `N.y' by running Yacc with the
562 recipe `$(YACC) $(YFLAGS)'.
565 `N.c' is made automatically from `N.l' by running Lex. The actual
566 recipe is `$(LEX) $(LFLAGS)'.
568 Lex for Ratfor programs
569 `N.r' is made automatically from `N.l' by running Lex. The actual
570 recipe is `$(LEX) $(LFLAGS)'.
572 The convention of using the same suffix `.l' for all Lex files
573 regardless of whether they produce C code or Ratfor code makes it
574 impossible for `make' to determine automatically which of the two
575 languages you are using in any particular case. If `make' is
576 called upon to remake an object file from a `.l' file, it must
577 guess which compiler to use. It will guess the C compiler, because
578 that is more common. If you are using Ratfor, make sure `make'
579 knows this by mentioning `N.r' in the makefile. Or, if you are
580 using Ratfor exclusively, with no C files, remove `.c' from the
581 list of implicit rule suffixes with:
584 .SUFFIXES: .o .r .f .l ...
586 Making Lint Libraries from C, Yacc, or Lex programs
587 `N.ln' is made from `N.c' by running `lint'. The precise recipe
588 is `$(LINT) $(LINTFLAGS) $(CPPFLAGS) -i'. The same recipe is used
589 on the C code produced from `N.y' or `N.l'.
592 `N.dvi' is made from `N.tex' with the recipe `$(TEX)'. `N.tex' is
593 made from `N.web' with `$(WEAVE)', or from `N.w' (and from `N.ch'
594 if it exists or can be made) with `$(CWEAVE)'. `N.p' is made from
595 `N.web' with `$(TANGLE)' and `N.c' is made from `N.w' (and from
596 `N.ch' if it exists or can be made) with `$(CTANGLE)'.
599 `N.dvi' is made from `N.texinfo', `N.texi', or `N.txinfo', with
600 the recipe `$(TEXI2DVI) $(TEXI2DVI_FLAGS)'. `N.info' is made from
601 `N.texinfo', `N.texi', or `N.txinfo', with the recipe
602 `$(MAKEINFO) $(MAKEINFO_FLAGS)'.
605 Any file `N' is extracted if necessary from an RCS file named
606 either `N,v' or `RCS/N,v'. The precise recipe used is
607 `$(CO) $(COFLAGS)'. `N' will not be extracted from RCS if it
608 already exists, even if the RCS file is newer. The rules for RCS
609 are terminal (*note Match-Anything Pattern Rules: Match-Anything
610 Rules.), so RCS files cannot be generated from another source;
611 they must actually exist.
614 Any file `N' is extracted if necessary from an SCCS file named
615 either `s.N' or `SCCS/s.N'. The precise recipe used is
616 `$(GET) $(GFLAGS)'. The rules for SCCS are terminal (*note
617 Match-Anything Pattern Rules: Match-Anything Rules.), so SCCS
618 files cannot be generated from another source; they must actually
621 For the benefit of SCCS, a file `N' is copied from `N.sh' and made
622 executable (by everyone). This is for shell scripts that are
623 checked into SCCS. Since RCS preserves the execution permission
624 of a file, you do not need to use this feature with RCS.
626 We recommend that you avoid using of SCCS. RCS is widely held to
627 be superior, and is also free. By choosing free software in place
628 of comparable (or inferior) proprietary software, you support the
629 free software movement.
631 Usually, you want to change only the variables listed in the table
632 above, which are documented in the following section.
634 However, the recipes in built-in implicit rules actually use
635 variables such as `COMPILE.c', `LINK.p', and `PREPROCESS.S', whose
636 values contain the recipes listed above.
638 `make' follows the convention that the rule to compile a `.X' source
639 file uses the variable `COMPILE.X'. Similarly, the rule to produce an
640 executable from a `.X' file uses `LINK.X'; and the rule to preprocess a
641 `.X' file uses `PREPROCESS.X'.
643 Every rule that produces an object file uses the variable
644 `OUTPUT_OPTION'. `make' defines this variable either to contain `-o
645 $@', or to be empty, depending on a compile-time option. You need the
646 `-o' option to ensure that the output goes into the right file when the
647 source file is in a different directory, as when using `VPATH' (*note
648 Directory Search::). However, compilers on some systems do not accept
649 a `-o' switch for object files. If you use such a system, and use
650 `VPATH', some compilations will put their output in the wrong place. A
651 possible workaround for this problem is to give `OUTPUT_OPTION' the
652 value `; mv $*.o $@'.
655 File: make.info, Node: Implicit Variables, Next: Chained Rules, Prev: Catalogue of Rules, Up: Implicit Rules
657 10.3 Variables Used by Implicit Rules
658 =====================================
660 The recipes in built-in implicit rules make liberal use of certain
661 predefined variables. You can alter the values of these variables in
662 the makefile, with arguments to `make', or in the environment to alter
663 how the implicit rules work without redefining the rules themselves.
664 You can cancel all variables used by implicit rules with the `-R' or
665 `--no-builtin-variables' option.
667 For example, the recipe used to compile a C source file actually says
668 `$(CC) -c $(CFLAGS) $(CPPFLAGS)'. The default values of the variables
669 used are `cc' and nothing, resulting in the command `cc -c'. By
670 redefining `CC' to `ncc', you could cause `ncc' to be used for all C
671 compilations performed by the implicit rule. By redefining `CFLAGS' to
672 be `-g', you could pass the `-g' option to each compilation. _All_
673 implicit rules that do C compilation use `$(CC)' to get the program
674 name for the compiler and _all_ include `$(CFLAGS)' among the arguments
675 given to the compiler.
677 The variables used in implicit rules fall into two classes: those
678 that are names of programs (like `CC') and those that contain arguments
679 for the programs (like `CFLAGS'). (The "name of a program" may also
680 contain some command arguments, but it must start with an actual
681 executable program name.) If a variable value contains more than one
682 argument, separate them with spaces.
684 The following tables describe of some of the more commonly-used
685 predefined variables. This list is not exhaustive, and the default
686 values shown here may not be what `make' selects for your environment.
687 To see the complete list of predefined variables for your instance of
688 GNU `make' you can run `make -p' in a directory with no makefiles.
690 Here is a table of some of the more common variables used as names of
691 programs in built-in rules:
694 Archive-maintaining program; default `ar'.
697 Program for compiling assembly files; default `as'.
700 Program for compiling C programs; default `cc'.
703 Program for compiling C++ programs; default `g++'.
706 Program for running the C preprocessor, with results to standard
707 output; default `$(CC) -E'.
710 Program for compiling or preprocessing Fortran and Ratfor programs;
714 Program to use to compile Modula-2 source code; default `m2c'.
717 Program for compiling Pascal programs; default `pc'.
720 Program for extracting a file from RCS; default `co'.
723 Program for extracting a file from SCCS; default `get'.
726 Program to use to turn Lex grammars into source code; default
730 Program to use to turn Yacc grammars into source code; default
734 Program to use to run lint on source code; default `lint'.
737 Program to convert a Texinfo source file into an Info file; default
741 Program to make TeX DVI files from TeX source; default `tex'.
744 Program to make TeX DVI files from Texinfo source; default
748 Program to translate Web into TeX; default `weave'.
751 Program to translate C Web into TeX; default `cweave'.
754 Program to translate Web into Pascal; default `tangle'.
757 Program to translate C Web into C; default `ctangle'.
760 Command to remove a file; default `rm -f'.
762 Here is a table of variables whose values are additional arguments
763 for the programs above. The default values for all of these is the
764 empty string, unless otherwise noted.
767 Flags to give the archive-maintaining program; default `rv'.
770 Extra flags to give to the assembler (when explicitly invoked on a
774 Extra flags to give to the C compiler.
777 Extra flags to give to the C++ compiler.
780 Extra flags to give to the RCS `co' program.
783 Extra flags to give to the C preprocessor and programs that use it
784 (the C and Fortran compilers).
787 Extra flags to give to the Fortran compiler.
790 Extra flags to give to the SCCS `get' program.
793 Extra flags to give to compilers when they are supposed to invoke
794 the linker, `ld', such as `-L'. Libraries (`-lfoo') should be
795 added to the `LDLIBS' variable instead.
798 Library flags or names given to compilers when they are supposed to
799 invoke the linker, `ld'. `LOADLIBES' is a deprecated (but still
800 supported) alternative to `LDLIBS'. Non-library linker flags,
801 such as `-L', should go in the `LDFLAGS' variable.
804 Extra flags to give to Lex.
807 Extra flags to give to Yacc.
810 Extra flags to give to the Pascal compiler.
813 Extra flags to give to the Fortran compiler for Ratfor programs.
816 Extra flags to give to lint.
819 File: make.info, Node: Chained Rules, Next: Pattern Rules, Prev: Implicit Variables, Up: Implicit Rules
821 10.4 Chains of Implicit Rules
822 =============================
824 Sometimes a file can be made by a sequence of implicit rules. For
825 example, a file `N.o' could be made from `N.y' by running first Yacc
826 and then `cc'. Such a sequence is called a "chain".
828 If the file `N.c' exists, or is mentioned in the makefile, no
829 special searching is required: `make' finds that the object file can be
830 made by C compilation from `N.c'; later on, when considering how to
831 make `N.c', the rule for running Yacc is used. Ultimately both `N.c'
832 and `N.o' are updated.
834 However, even if `N.c' does not exist and is not mentioned, `make'
835 knows how to envision it as the missing link between `N.o' and `N.y'!
836 In this case, `N.c' is called an "intermediate file". Once `make' has
837 decided to use the intermediate file, it is entered in the data base as
838 if it had been mentioned in the makefile, along with the implicit rule
839 that says how to create it.
841 Intermediate files are remade using their rules just like all other
842 files. But intermediate files are treated differently in two ways.
844 The first difference is what happens if the intermediate file does
845 not exist. If an ordinary file B does not exist, and `make' considers
846 a target that depends on B, it invariably creates B and then updates
847 the target from B. But if B is an intermediate file, then `make' can
848 leave well enough alone. It won't bother updating B, or the ultimate
849 target, unless some prerequisite of B is newer than that target or
850 there is some other reason to update that target.
852 The second difference is that if `make' _does_ create B in order to
853 update something else, it deletes B later on after it is no longer
854 needed. Therefore, an intermediate file which did not exist before
855 `make' also does not exist after `make'. `make' reports the deletion
856 to you by printing a `rm -f' command showing which file it is deleting.
858 Ordinarily, a file cannot be intermediate if it is mentioned in the
859 makefile as a target or prerequisite. However, you can explicitly mark
860 a file as intermediate by listing it as a prerequisite of the special
861 target `.INTERMEDIATE'. This takes effect even if the file is mentioned
862 explicitly in some other way.
864 You can prevent automatic deletion of an intermediate file by
865 marking it as a "secondary" file. To do this, list it as a
866 prerequisite of the special target `.SECONDARY'. When a file is
867 secondary, `make' will not create the file merely because it does not
868 already exist, but `make' does not automatically delete the file.
869 Marking a file as secondary also marks it as intermediate.
871 You can list the target pattern of an implicit rule (such as `%.o')
872 as a prerequisite of the special target `.PRECIOUS' to preserve
873 intermediate files made by implicit rules whose target patterns match
874 that file's name; see *note Interrupts::.
876 A chain can involve more than two implicit rules. For example, it is
877 possible to make a file `foo' from `RCS/foo.y,v' by running RCS, Yacc
878 and `cc'. Then both `foo.y' and `foo.c' are intermediate files that
879 are deleted at the end.
881 No single implicit rule can appear more than once in a chain. This
882 means that `make' will not even consider such a ridiculous thing as
883 making `foo' from `foo.o.o' by running the linker twice. This
884 constraint has the added benefit of preventing any infinite loop in the
885 search for an implicit rule chain.
887 There are some special implicit rules to optimize certain cases that
888 would otherwise be handled by rule chains. For example, making `foo'
889 from `foo.c' could be handled by compiling and linking with separate
890 chained rules, using `foo.o' as an intermediate file. But what
891 actually happens is that a special rule for this case does the
892 compilation and linking with a single `cc' command. The optimized rule
893 is used in preference to the step-by-step chain because it comes
894 earlier in the ordering of rules.
897 File: make.info, Node: Pattern Rules, Next: Last Resort, Prev: Chained Rules, Up: Implicit Rules
899 10.5 Defining and Redefining Pattern Rules
900 ==========================================
902 You define an implicit rule by writing a "pattern rule". A pattern
903 rule looks like an ordinary rule, except that its target contains the
904 character `%' (exactly one of them). The target is considered a
905 pattern for matching file names; the `%' can match any nonempty
906 substring, while other characters match only themselves. The
907 prerequisites likewise use `%' to show how their names relate to the
910 Thus, a pattern rule `%.o : %.c' says how to make any file `STEM.o'
911 from another file `STEM.c'.
913 Note that expansion using `%' in pattern rules occurs *after* any
914 variable or function expansions, which take place when the makefile is
915 read. *Note How to Use Variables: Using Variables, and *note Functions
916 for Transforming Text: Functions.
920 * Pattern Intro:: An introduction to pattern rules.
921 * Pattern Examples:: Examples of pattern rules.
922 * Automatic Variables:: How to use automatic variables in the
923 recipe of implicit rules.
924 * Pattern Match:: How patterns match.
925 * Match-Anything Rules:: Precautions you should take prior to
926 defining rules that can match any
927 target file whatever.
928 * Canceling Rules:: How to override or cancel built-in rules.
931 File: make.info, Node: Pattern Intro, Next: Pattern Examples, Prev: Pattern Rules, Up: Pattern Rules
933 10.5.1 Introduction to Pattern Rules
934 ------------------------------------
936 A pattern rule contains the character `%' (exactly one of them) in the
937 target; otherwise, it looks exactly like an ordinary rule. The target
938 is a pattern for matching file names; the `%' matches any nonempty
939 substring, while other characters match only themselves.
941 For example, `%.c' as a pattern matches any file name that ends in
942 `.c'. `s.%.c' as a pattern matches any file name that starts with
943 `s.', ends in `.c' and is at least five characters long. (There must
944 be at least one character to match the `%'.) The substring that the
945 `%' matches is called the "stem".
947 `%' in a prerequisite of a pattern rule stands for the same stem
948 that was matched by the `%' in the target. In order for the pattern
949 rule to apply, its target pattern must match the file name under
950 consideration and all of its prerequisites (after pattern substitution)
951 must name files that exist or can be made. These files become
952 prerequisites of the target.
954 Thus, a rule of the form
956 %.o : %.c ; RECIPE...
958 specifies how to make a file `N.o', with another file `N.c' as its
959 prerequisite, provided that `N.c' exists or can be made.
961 There may also be prerequisites that do not use `%'; such a
962 prerequisite attaches to every file made by this pattern rule. These
963 unvarying prerequisites are useful occasionally.
965 A pattern rule need not have any prerequisites that contain `%', or
966 in fact any prerequisites at all. Such a rule is effectively a general
967 wildcard. It provides a way to make any file that matches the target
968 pattern. *Note Last Resort::.
970 More than one pattern rule may match a target. In this case `make'
971 will choose the "best fit" rule. *Note How Patterns Match: Pattern
974 Pattern rules may have more than one target. Unlike normal rules,
975 this does not act as many different rules with the same prerequisites
976 and recipe. If a pattern rule has multiple targets, `make' knows that
977 the rule's recipe is responsible for making all of the targets. The
978 recipe is executed only once to make all the targets. When searching
979 for a pattern rule to match a target, the target patterns of a rule
980 other than the one that matches the target in need of a rule are
981 incidental: `make' worries only about giving a recipe and prerequisites
982 to the file presently in question. However, when this file's recipe is
983 run, the other targets are marked as having been updated themselves.
986 File: make.info, Node: Pattern Examples, Next: Automatic Variables, Prev: Pattern Intro, Up: Pattern Rules
988 10.5.2 Pattern Rule Examples
989 ----------------------------
991 Here are some examples of pattern rules actually predefined in `make'.
992 First, the rule that compiles `.c' files into `.o' files:
995 $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@
997 defines a rule that can make any file `X.o' from `X.c'. The recipe
998 uses the automatic variables `$@' and `$<' to substitute the names of
999 the target file and the source file in each case where the rule applies
1000 (*note Automatic Variables::).
1002 Here is a second built-in rule:
1007 defines a rule that can make any file `X' whatsoever from a
1008 corresponding file `X,v' in the sub-directory `RCS'. Since the target
1009 is `%', this rule will apply to any file whatever, provided the
1010 appropriate prerequisite file exists. The double colon makes the rule
1011 "terminal", which means that its prerequisite may not be an intermediate
1012 file (*note Match-Anything Pattern Rules: Match-Anything Rules.).
1014 This pattern rule has two targets:
1016 %.tab.c %.tab.h: %.y
1019 This tells `make' that the recipe `bison -d X.y' will make both
1020 `X.tab.c' and `X.tab.h'. If the file `foo' depends on the files
1021 `parse.tab.o' and `scan.o' and the file `scan.o' depends on the file
1022 `parse.tab.h', when `parse.y' is changed, the recipe `bison -d parse.y'
1023 will be executed only once, and the prerequisites of both `parse.tab.o'
1024 and `scan.o' will be satisfied. (Presumably the file `parse.tab.o'
1025 will be recompiled from `parse.tab.c' and the file `scan.o' from
1026 `scan.c', while `foo' is linked from `parse.tab.o', `scan.o', and its
1027 other prerequisites, and it will execute happily ever after.)
1030 File: make.info, Node: Automatic Variables, Next: Pattern Match, Prev: Pattern Examples, Up: Pattern Rules
1032 10.5.3 Automatic Variables
1033 --------------------------
1035 Suppose you are writing a pattern rule to compile a `.c' file into a
1036 `.o' file: how do you write the `cc' command so that it operates on the
1037 right source file name? You cannot write the name in the recipe,
1038 because the name is different each time the implicit rule is applied.
1040 What you do is use a special feature of `make', the "automatic
1041 variables". These variables have values computed afresh for each rule
1042 that is executed, based on the target and prerequisites of the rule.
1043 In this example, you would use `$@' for the object file name and `$<'
1044 for the source file name.
1046 It's very important that you recognize the limited scope in which
1047 automatic variable values are available: they only have values within
1048 the recipe. In particular, you cannot use them anywhere within the
1049 target list of a rule; they have no value there and will expand to the
1050 empty string. Also, they cannot be accessed directly within the
1051 prerequisite list of a rule. A common mistake is attempting to use
1052 `$@' within the prerequisites list; this will not work. However, there
1053 is a special feature of GNU `make', secondary expansion (*note
1054 Secondary Expansion::), which will allow automatic variable values to
1055 be used in prerequisite lists.
1057 Here is a table of automatic variables:
1060 The file name of the target of the rule. If the target is an
1061 archive member, then `$@' is the name of the archive file. In a
1062 pattern rule that has multiple targets (*note Introduction to
1063 Pattern Rules: Pattern Intro.), `$@' is the name of whichever
1064 target caused the rule's recipe to be run.
1067 The target member name, when the target is an archive member.
1068 *Note Archives::. For example, if the target is `foo.a(bar.o)'
1069 then `$%' is `bar.o' and `$@' is `foo.a'. `$%' is empty when the
1070 target is not an archive member.
1073 The name of the first prerequisite. If the target got its recipe
1074 from an implicit rule, this will be the first prerequisite added
1075 by the implicit rule (*note Implicit Rules::).
1078 The names of all the prerequisites that are newer than the target,
1079 with spaces between them. For prerequisites which are archive
1080 members, only the named member is used (*note Archives::).
1083 The names of all the prerequisites, with spaces between them. For
1084 prerequisites which are archive members, only the named member is
1085 used (*note Archives::). A target has only one prerequisite on
1086 each other file it depends on, no matter how many times each file
1087 is listed as a prerequisite. So if you list a prerequisite more
1088 than once for a target, the value of `$^' contains just one copy
1089 of the name. This list does *not* contain any of the order-only
1090 prerequisites; for those see the `$|' variable, below.
1093 This is like `$^', but prerequisites listed more than once are
1094 duplicated in the order they were listed in the makefile. This is
1095 primarily useful for use in linking commands where it is
1096 meaningful to repeat library file names in a particular order.
1099 The names of all the order-only prerequisites, with spaces between
1103 The stem with which an implicit rule matches (*note How Patterns
1104 Match: Pattern Match.). If the target is `dir/a.foo.b' and the
1105 target pattern is `a.%.b' then the stem is `dir/foo'. The stem is
1106 useful for constructing names of related files.
1108 In a static pattern rule, the stem is part of the file name that
1109 matched the `%' in the target pattern.
1111 In an explicit rule, there is no stem; so `$*' cannot be determined
1112 in that way. Instead, if the target name ends with a recognized
1113 suffix (*note Old-Fashioned Suffix Rules: Suffix Rules.), `$*' is
1114 set to the target name minus the suffix. For example, if the
1115 target name is `foo.c', then `$*' is set to `foo', since `.c' is a
1116 suffix. GNU `make' does this bizarre thing only for compatibility
1117 with other implementations of `make'. You should generally avoid
1118 using `$*' except in implicit rules or static pattern rules.
1120 If the target name in an explicit rule does not end with a
1121 recognized suffix, `$*' is set to the empty string for that rule.
1123 `$?' is useful even in explicit rules when you wish to operate on
1124 only the prerequisites that have changed. For example, suppose that an
1125 archive named `lib' is supposed to contain copies of several object
1126 files. This rule copies just the changed object files into the archive:
1128 lib: foo.o bar.o lose.o win.o
1131 Of the variables listed above, four have values that are single file
1132 names, and three have values that are lists of file names. These seven
1133 have variants that get just the file's directory name or just the file
1134 name within the directory. The variant variables' names are formed by
1135 appending `D' or `F', respectively. These variants are semi-obsolete
1136 in GNU `make' since the functions `dir' and `notdir' can be used to get
1137 a similar effect (*note Functions for File Names: File Name
1138 Functions.). Note, however, that the `D' variants all omit the
1139 trailing slash which always appears in the output of the `dir'
1140 function. Here is a table of the variants:
1143 The directory part of the file name of the target, with the
1144 trailing slash removed. If the value of `$@' is `dir/foo.o' then
1145 `$(@D)' is `dir'. This value is `.' if `$@' does not contain a
1149 The file-within-directory part of the file name of the target. If
1150 the value of `$@' is `dir/foo.o' then `$(@F)' is `foo.o'. `$(@F)'
1151 is equivalent to `$(notdir $@)'.
1155 The directory part and the file-within-directory part of the stem;
1156 `dir' and `foo' in this example.
1160 The directory part and the file-within-directory part of the target
1161 archive member name. This makes sense only for archive member
1162 targets of the form `ARCHIVE(MEMBER)' and is useful only when
1163 MEMBER may contain a directory name. (*Note Archive Members as
1164 Targets: Archive Members.)
1168 The directory part and the file-within-directory part of the first
1173 Lists of the directory parts and the file-within-directory parts
1174 of all prerequisites.
1178 Lists of the directory parts and the file-within-directory parts
1179 of all prerequisites, including multiple instances of duplicated
1184 Lists of the directory parts and the file-within-directory parts of
1185 all prerequisites that are newer than the target.
1187 Note that we use a special stylistic convention when we talk about
1188 these automatic variables; we write "the value of `$<'", rather than
1189 "the variable `<'" as we would write for ordinary variables such as
1190 `objects' and `CFLAGS'. We think this convention looks more natural in
1191 this special case. Please do not assume it has a deep significance;
1192 `$<' refers to the variable named `<' just as `$(CFLAGS)' refers to the
1193 variable named `CFLAGS'. You could just as well use `$(<)' in place of
1197 File: make.info, Node: Pattern Match, Next: Match-Anything Rules, Prev: Automatic Variables, Up: Pattern Rules
1199 10.5.4 How Patterns Match
1200 -------------------------
1202 A target pattern is composed of a `%' between a prefix and a suffix,
1203 either or both of which may be empty. The pattern matches a file name
1204 only if the file name starts with the prefix and ends with the suffix,
1205 without overlap. The text between the prefix and the suffix is called
1206 the "stem". Thus, when the pattern `%.o' matches the file name
1207 `test.o', the stem is `test'. The pattern rule prerequisites are
1208 turned into actual file names by substituting the stem for the character
1209 `%'. Thus, if in the same example one of the prerequisites is written
1210 as `%.c', it expands to `test.c'.
1212 When the target pattern does not contain a slash (and it usually does
1213 not), directory names in the file names are removed from the file name
1214 before it is compared with the target prefix and suffix. After the
1215 comparison of the file name to the target pattern, the directory names,
1216 along with the slash that ends them, are added on to the prerequisite
1217 file names generated from the pattern rule's prerequisite patterns and
1218 the file name. The directories are ignored only for the purpose of
1219 finding an implicit rule to use, not in the application of that rule.
1220 Thus, `e%t' matches the file name `src/eat', with `src/a' as the stem.
1221 When prerequisites are turned into file names, the directories from the
1222 stem are added at the front, while the rest of the stem is substituted
1223 for the `%'. The stem `src/a' with a prerequisite pattern `c%r' gives
1224 the file name `src/car'.
1226 A pattern rule can be used to build a given file only if there is a
1227 target pattern that matches the file name, _and_ all prerequisites in
1228 that rule either exist or can be built. The rules you write take
1229 precedence over those that are built in. Note however, that a rule
1230 whose prerequisites actually exist or are mentioned always takes
1231 priority over a rule with prerequisites that must be made by chaining
1232 other implicit rules.
1234 It is possible that more than one pattern rule will meet these
1235 criteria. In that case, `make' will choose the rule with the shortest
1236 stem (that is, the pattern that matches most specifically). If more
1237 than one pattern rule has the shortest stem, `make' will choose the
1238 first one found in the makefile.
1240 This algorithm results in more specific rules being preferred over
1241 more generic ones; for example:
1244 $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@
1247 $(COMPILE.F) $(OUTPUT_OPTION) $<
1250 $(CC) -fPIC -c $(CFLAGS) $(CPPFLAGS) $< -o $@
1252 Given these rules and asked to build `bar.o' where both `bar.c' and
1253 `bar.f' exist, `make' will choose the first rule and compile `bar.c'
1254 into `bar.o'. In the same situation where `bar.c' does not exist, then
1255 `make' will choose the second rule and compile `bar.f' into `bar.o'.
1257 If `make' is asked to build `lib/bar.o' and both `lib/bar.c' and
1258 `lib/bar.f' exist, then the third rule will be chosen since the stem
1259 for this rule (`bar') is shorter than the stem for the first rule
1260 (`lib/bar'). If `lib/bar.c' does not exist then the third rule is not
1261 eligible and the second rule will be used, even though the stem is
1265 File: make.info, Node: Match-Anything Rules, Next: Canceling Rules, Prev: Pattern Match, Up: Pattern Rules
1267 10.5.5 Match-Anything Pattern Rules
1268 -----------------------------------
1270 When a pattern rule's target is just `%', it matches any file name
1271 whatever. We call these rules "match-anything" rules. They are very
1272 useful, but it can take a lot of time for `make' to think about them,
1273 because it must consider every such rule for each file name listed
1274 either as a target or as a prerequisite.
1276 Suppose the makefile mentions `foo.c'. For this target, `make'
1277 would have to consider making it by linking an object file `foo.c.o',
1278 or by C compilation-and-linking in one step from `foo.c.c', or by
1279 Pascal compilation-and-linking from `foo.c.p', and many other
1282 We know these possibilities are ridiculous since `foo.c' is a C
1283 source file, not an executable. If `make' did consider these
1284 possibilities, it would ultimately reject them, because files such as
1285 `foo.c.o' and `foo.c.p' would not exist. But these possibilities are so
1286 numerous that `make' would run very slowly if it had to consider them.
1288 To gain speed, we have put various constraints on the way `make'
1289 considers match-anything rules. There are two different constraints
1290 that can be applied, and each time you define a match-anything rule you
1291 must choose one or the other for that rule.
1293 One choice is to mark the match-anything rule as "terminal" by
1294 defining it with a double colon. When a rule is terminal, it does not
1295 apply unless its prerequisites actually exist. Prerequisites that
1296 could be made with other implicit rules are not good enough. In other
1297 words, no further chaining is allowed beyond a terminal rule.
1299 For example, the built-in implicit rules for extracting sources from
1300 RCS and SCCS files are terminal; as a result, if the file `foo.c,v' does
1301 not exist, `make' will not even consider trying to make it as an
1302 intermediate file from `foo.c,v.o' or from `RCS/SCCS/s.foo.c,v'. RCS
1303 and SCCS files are generally ultimate source files, which should not be
1304 remade from any other files; therefore, `make' can save time by not
1305 looking for ways to remake them.
1307 If you do not mark the match-anything rule as terminal, then it is
1308 non-terminal. A non-terminal match-anything rule cannot apply to a
1309 file name that indicates a specific type of data. A file name
1310 indicates a specific type of data if some non-match-anything implicit
1311 rule target matches it.
1313 For example, the file name `foo.c' matches the target for the pattern
1314 rule `%.c : %.y' (the rule to run Yacc). Regardless of whether this
1315 rule is actually applicable (which happens only if there is a file
1316 `foo.y'), the fact that its target matches is enough to prevent
1317 consideration of any non-terminal match-anything rules for the file
1318 `foo.c'. Thus, `make' will not even consider trying to make `foo.c' as
1319 an executable file from `foo.c.o', `foo.c.c', `foo.c.p', etc.
1321 The motivation for this constraint is that non-terminal
1322 match-anything rules are used for making files containing specific
1323 types of data (such as executable files) and a file name with a
1324 recognized suffix indicates some other specific type of data (such as a
1327 Special built-in dummy pattern rules are provided solely to recognize
1328 certain file names so that non-terminal match-anything rules will not be
1329 considered. These dummy rules have no prerequisites and no recipes, and
1330 they are ignored for all other purposes. For example, the built-in
1335 exists to make sure that Pascal source files such as `foo.p' match a
1336 specific target pattern and thereby prevent time from being wasted
1337 looking for `foo.p.o' or `foo.p.c'.
1339 Dummy pattern rules such as the one for `%.p' are made for every
1340 suffix listed as valid for use in suffix rules (*note Old-Fashioned
1341 Suffix Rules: Suffix Rules.).
1344 File: make.info, Node: Canceling Rules, Prev: Match-Anything Rules, Up: Pattern Rules
1346 10.5.6 Canceling Implicit Rules
1347 -------------------------------
1349 You can override a built-in implicit rule (or one you have defined
1350 yourself) by defining a new pattern rule with the same target and
1351 prerequisites, but a different recipe. When the new rule is defined,
1352 the built-in one is replaced. The new rule's position in the sequence
1353 of implicit rules is determined by where you write the new rule.
1355 You can cancel a built-in implicit rule by defining a pattern rule
1356 with the same target and prerequisites, but no recipe. For example,
1357 the following would cancel the rule that runs the assembler:
1362 File: make.info, Node: Last Resort, Next: Suffix Rules, Prev: Pattern Rules, Up: Implicit Rules
1364 10.6 Defining Last-Resort Default Rules
1365 =======================================
1367 You can define a last-resort implicit rule by writing a terminal
1368 match-anything pattern rule with no prerequisites (*note Match-Anything
1369 Rules::). This is just like any other pattern rule; the only thing
1370 special about it is that it will match any target. So such a rule's
1371 recipe is used for all targets and prerequisites that have no recipe of
1372 their own and for which no other implicit rule applies.
1374 For example, when testing a makefile, you might not care if the
1375 source files contain real data, only that they exist. Then you might
1381 to cause all the source files needed (as prerequisites) to be created
1384 You can instead define a recipe to be used for targets for which
1385 there are no rules at all, even ones which don't specify recipes. You
1386 do this by writing a rule for the target `.DEFAULT'. Such a rule's
1387 recipe is used for all prerequisites which do not appear as targets in
1388 any explicit rule, and for which no implicit rule applies. Naturally,
1389 there is no `.DEFAULT' rule unless you write one.
1391 If you use `.DEFAULT' with no recipe or prerequisites:
1395 the recipe previously stored for `.DEFAULT' is cleared. Then `make'
1396 acts as if you had never defined `.DEFAULT' at all.
1398 If you do not want a target to get the recipe from a match-anything
1399 pattern rule or `.DEFAULT', but you also do not want any recipe to be
1400 run for the target, you can give it an empty recipe (*note Defining
1401 Empty Recipes: Empty Recipes.).
1403 You can use a last-resort rule to override part of another makefile.
1404 *Note Overriding Part of Another Makefile: Overriding Makefiles.
1407 File: make.info, Node: Suffix Rules, Next: Implicit Rule Search, Prev: Last Resort, Up: Implicit Rules
1409 10.7 Old-Fashioned Suffix Rules
1410 ===============================
1412 "Suffix rules" are the old-fashioned way of defining implicit rules for
1413 `make'. Suffix rules are obsolete because pattern rules are more
1414 general and clearer. They are supported in GNU `make' for
1415 compatibility with old makefiles. They come in two kinds:
1416 "double-suffix" and "single-suffix".
1418 A double-suffix rule is defined by a pair of suffixes: the target
1419 suffix and the source suffix. It matches any file whose name ends with
1420 the target suffix. The corresponding implicit prerequisite is made by
1421 replacing the target suffix with the source suffix in the file name. A
1422 two-suffix rule whose target and source suffixes are `.o' and `.c' is
1423 equivalent to the pattern rule `%.o : %.c'.
1425 A single-suffix rule is defined by a single suffix, which is the
1426 source suffix. It matches any file name, and the corresponding implicit
1427 prerequisite name is made by appending the source suffix. A
1428 single-suffix rule whose source suffix is `.c' is equivalent to the
1429 pattern rule `% : %.c'.
1431 Suffix rule definitions are recognized by comparing each rule's
1432 target against a defined list of known suffixes. When `make' sees a
1433 rule whose target is a known suffix, this rule is considered a
1434 single-suffix rule. When `make' sees a rule whose target is two known
1435 suffixes concatenated, this rule is taken as a double-suffix rule.
1437 For example, `.c' and `.o' are both on the default list of known
1438 suffixes. Therefore, if you define a rule whose target is `.c.o',
1439 `make' takes it to be a double-suffix rule with source suffix `.c' and
1440 target suffix `.o'. Here is the old-fashioned way to define the rule
1441 for compiling a C source file:
1444 $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
1446 Suffix rules cannot have any prerequisites of their own. If they
1447 have any, they are treated as normal files with funny names, not as
1448 suffix rules. Thus, the rule:
1451 $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
1453 tells how to make the file `.c.o' from the prerequisite file `foo.h',
1454 and is not at all like the pattern rule:
1457 $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
1459 which tells how to make `.o' files from `.c' files, and makes all `.o'
1460 files using this pattern rule also depend on `foo.h'.
1462 Suffix rules with no recipe are also meaningless. They do not remove
1463 previous rules as do pattern rules with no recipe (*note Canceling
1464 Implicit Rules: Canceling Rules.). They simply enter the suffix or
1465 pair of suffixes concatenated as a target in the data base.
1467 The known suffixes are simply the names of the prerequisites of the
1468 special target `.SUFFIXES'. You can add your own suffixes by writing a
1469 rule for `.SUFFIXES' that adds more prerequisites, as in:
1471 .SUFFIXES: .hack .win
1473 which adds `.hack' and `.win' to the end of the list of suffixes.
1475 If you wish to eliminate the default known suffixes instead of just
1476 adding to them, write a rule for `.SUFFIXES' with no prerequisites. By
1477 special dispensation, this eliminates all existing prerequisites of
1478 `.SUFFIXES'. You can then write another rule to add the suffixes you
1481 .SUFFIXES: # Delete the default suffixes
1482 .SUFFIXES: .c .o .h # Define our suffix list
1484 The `-r' or `--no-builtin-rules' flag causes the default list of
1485 suffixes to be empty.
1487 The variable `SUFFIXES' is defined to the default list of suffixes
1488 before `make' reads any makefiles. You can change the list of suffixes
1489 with a rule for the special target `.SUFFIXES', but that does not alter
1493 File: make.info, Node: Implicit Rule Search, Prev: Suffix Rules, Up: Implicit Rules
1495 10.8 Implicit Rule Search Algorithm
1496 ===================================
1498 Here is the procedure `make' uses for searching for an implicit rule
1499 for a target T. This procedure is followed for each double-colon rule
1500 with no recipe, for each target of ordinary rules none of which have a
1501 recipe, and for each prerequisite that is not the target of any rule.
1502 It is also followed recursively for prerequisites that come from
1503 implicit rules, in the search for a chain of rules.
1505 Suffix rules are not mentioned in this algorithm because suffix
1506 rules are converted to equivalent pattern rules once the makefiles have
1509 For an archive member target of the form `ARCHIVE(MEMBER)', the
1510 following algorithm is run twice, first using the entire target name T,
1511 and second using `(MEMBER)' as the target T if the first run found no
1514 1. Split T into a directory part, called D, and the rest, called N.
1515 For example, if T is `src/foo.o', then D is `src/' and N is
1518 2. Make a list of all the pattern rules one of whose targets matches
1519 T or N. If the target pattern contains a slash, it is matched
1520 against T; otherwise, against N.
1522 3. If any rule in that list is _not_ a match-anything rule, then
1523 remove all non-terminal match-anything rules from the list.
1525 4. Remove from the list all rules with no recipe.
1527 5. For each pattern rule in the list:
1529 a. Find the stem S, which is the nonempty part of T or N matched
1530 by the `%' in the target pattern.
1532 b. Compute the prerequisite names by substituting S for `%'; if
1533 the target pattern does not contain a slash, append D to the
1534 front of each prerequisite name.
1536 c. Test whether all the prerequisites exist or ought to exist.
1537 (If a file name is mentioned in the makefile as a target or
1538 as an explicit prerequisite, then we say it ought to exist.)
1540 If all prerequisites exist or ought to exist, or there are no
1541 prerequisites, then this rule applies.
1543 6. If no pattern rule has been found so far, try harder. For each
1544 pattern rule in the list:
1546 a. If the rule is terminal, ignore it and go on to the next rule.
1548 b. Compute the prerequisite names as before.
1550 c. Test whether all the prerequisites exist or ought to exist.
1552 d. For each prerequisite that does not exist, follow this
1553 algorithm recursively to see if the prerequisite can be made
1554 by an implicit rule.
1556 e. If all prerequisites exist, ought to exist, or can be made by
1557 implicit rules, then this rule applies.
1559 7. If no implicit rule applies, the rule for `.DEFAULT', if any,
1560 applies. In that case, give T the same recipe that `.DEFAULT'
1561 has. Otherwise, there is no recipe for T.
1563 Once a rule that applies has been found, for each target pattern of
1564 the rule other than the one that matched T or N, the `%' in the pattern
1565 is replaced with S and the resultant file name is stored until the
1566 recipe to remake the target file T is executed. After the recipe is
1567 executed, each of these stored file names are entered into the data
1568 base and marked as having been updated and having the same update
1569 status as the file T.
1571 When the recipe of a pattern rule is executed for T, the automatic
1572 variables are set corresponding to the target and prerequisites. *Note
1573 Automatic Variables::.
1576 File: make.info, Node: Archives, Next: Extending make, Prev: Implicit Rules, Up: Top
1578 11 Using `make' to Update Archive Files
1579 ***************************************
1581 "Archive files" are files containing named sub-files called "members";
1582 they are maintained with the program `ar' and their main use is as
1583 subroutine libraries for linking.
1587 * Archive Members:: Archive members as targets.
1588 * Archive Update:: The implicit rule for archive member targets.
1589 * Archive Pitfalls:: Dangers to watch out for when using archives.
1590 * Archive Suffix Rules:: You can write a special kind of suffix rule
1591 for updating archives.
1594 File: make.info, Node: Archive Members, Next: Archive Update, Prev: Archives, Up: Archives
1596 11.1 Archive Members as Targets
1597 ===============================
1599 An individual member of an archive file can be used as a target or
1600 prerequisite in `make'. You specify the member named MEMBER in archive
1601 file ARCHIVE as follows:
1605 This construct is available only in targets and prerequisites, not in
1606 recipes! Most programs that you might use in recipes do not support
1607 this syntax and cannot act directly on archive members. Only `ar' and
1608 other programs specifically designed to operate on archives can do so.
1609 Therefore, valid recipes to update an archive member target probably
1610 must use `ar'. For example, this rule says to create a member `hack.o'
1611 in archive `foolib' by copying the file `hack.o':
1613 foolib(hack.o) : hack.o
1616 In fact, nearly all archive member targets are updated in just this
1617 way and there is an implicit rule to do it for you. *Please note:* The
1618 `c' flag to `ar' is required if the archive file does not already exist.
1620 To specify several members in the same archive, you can write all the
1621 member names together between the parentheses. For example:
1623 foolib(hack.o kludge.o)
1627 foolib(hack.o) foolib(kludge.o)
1629 You can also use shell-style wildcards in an archive member
1630 reference. *Note Using Wildcard Characters in File Names: Wildcards.
1631 For example, `foolib(*.o)' expands to all existing members of the
1632 `foolib' archive whose names end in `.o'; perhaps `foolib(hack.o)
1636 File: make.info, Node: Archive Update, Next: Archive Pitfalls, Prev: Archive Members, Up: Archives
1638 11.2 Implicit Rule for Archive Member Targets
1639 =============================================
1641 Recall that a target that looks like `A(M)' stands for the member named
1642 M in the archive file A.
1644 When `make' looks for an implicit rule for such a target, as a
1645 special feature it considers implicit rules that match `(M)', as well as
1646 those that match the actual target `A(M)'.
1648 This causes one special rule whose target is `(%)' to match. This
1649 rule updates the target `A(M)' by copying the file M into the archive.
1650 For example, it will update the archive member target `foo.a(bar.o)' by
1651 copying the _file_ `bar.o' into the archive `foo.a' as a _member_ named
1654 When this rule is chained with others, the result is very powerful.
1655 Thus, `make "foo.a(bar.o)"' (the quotes are needed to protect the `('
1656 and `)' from being interpreted specially by the shell) in the presence
1657 of a file `bar.c' is enough to cause the following recipe to be run,
1658 even without a makefile:
1660 cc -c bar.c -o bar.o
1664 Here `make' has envisioned the file `bar.o' as an intermediate file.
1665 *Note Chains of Implicit Rules: Chained Rules.
1667 Implicit rules such as this one are written using the automatic
1668 variable `$%'. *Note Automatic Variables::.
1670 An archive member name in an archive cannot contain a directory
1671 name, but it may be useful in a makefile to pretend that it does. If
1672 you write an archive member target `foo.a(dir/file.o)', `make' will
1673 perform automatic updating with this recipe:
1675 ar r foo.a dir/file.o
1677 which has the effect of copying the file `dir/file.o' into a member
1678 named `file.o'. In connection with such usage, the automatic variables
1679 `%D' and `%F' may be useful.
1683 * Archive Symbols:: How to update archive symbol directories.
1686 File: make.info, Node: Archive Symbols, Prev: Archive Update, Up: Archive Update
1688 11.2.1 Updating Archive Symbol Directories
1689 ------------------------------------------
1691 An archive file that is used as a library usually contains a special
1692 member named `__.SYMDEF' that contains a directory of the external
1693 symbol names defined by all the other members. After you update any
1694 other members, you need to update `__.SYMDEF' so that it will summarize
1695 the other members properly. This is done by running the `ranlib'
1700 Normally you would put this command in the rule for the archive file,
1701 and make all the members of the archive file prerequisites of that rule.
1704 libfoo.a: libfoo.a(x.o) libfoo.a(y.o) ...
1707 The effect of this is to update archive members `x.o', `y.o', etc., and
1708 then update the symbol directory member `__.SYMDEF' by running
1709 `ranlib'. The rules for updating the members are not shown here; most
1710 likely you can omit them and use the implicit rule which copies files
1711 into the archive, as described in the preceding section.
1713 This is not necessary when using the GNU `ar' program, which updates
1714 the `__.SYMDEF' member automatically.
1717 File: make.info, Node: Archive Pitfalls, Next: Archive Suffix Rules, Prev: Archive Update, Up: Archives
1719 11.3 Dangers When Using Archives
1720 ================================
1722 It is important to be careful when using parallel execution (the `-j'
1723 switch; *note Parallel Execution: Parallel.) and archives. If multiple
1724 `ar' commands run at the same time on the same archive file, they will
1725 not know about each other and can corrupt the file.
1727 Possibly a future version of `make' will provide a mechanism to
1728 circumvent this problem by serializing all recipes that operate on the
1729 same archive file. But for the time being, you must either write your
1730 makefiles to avoid this problem in some other way, or not use `-j'.
1733 File: make.info, Node: Archive Suffix Rules, Prev: Archive Pitfalls, Up: Archives
1735 11.4 Suffix Rules for Archive Files
1736 ===================================
1738 You can write a special kind of suffix rule for dealing with archive
1739 files. *Note Suffix Rules::, for a full explanation of suffix rules.
1740 Archive suffix rules are obsolete in GNU `make', because pattern rules
1741 for archives are a more general mechanism (*note Archive Update::).
1742 But they are retained for compatibility with other `make's.
1744 To write a suffix rule for archives, you simply write a suffix rule
1745 using the target suffix `.a' (the usual suffix for archive files). For
1746 example, here is the old-fashioned suffix rule to update a library
1747 archive from C source files:
1750 $(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $*.o
1754 This works just as if you had written the pattern rule:
1757 $(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $*.o
1761 In fact, this is just what `make' does when it sees a suffix rule
1762 with `.a' as the target suffix. Any double-suffix rule `.X.a' is
1763 converted to a pattern rule with the target pattern `(%.o)' and a
1764 prerequisite pattern of `%.X'.
1766 Since you might want to use `.a' as the suffix for some other kind
1767 of file, `make' also converts archive suffix rules to pattern rules in
1768 the normal way (*note Suffix Rules::). Thus a double-suffix rule
1769 `.X.a' produces two pattern rules: `(%.o): %.X' and `%.a: %.X'.
1772 File: make.info, Node: Extending make, Next: Features, Prev: Archives, Up: Top
1774 12 Extending GNU `make'
1775 ***********************
1777 GNU `make' provides many advanced capabilities, including many useful
1778 functions. However, it does not contain a complete programming
1779 language and so it has limitations. Sometimes these limitations can be
1780 overcome through use of the `shell' function to invoke a separate
1781 program, although this can be inefficient.
1783 In cases where the built-in capabilities of GNU `make' are
1784 insufficient to your requirements there are two options for extending
1785 `make'. On systems where it's provided, you can utilize GNU Guile as
1786 an embedded scripting language (*note GNU Guile Integration: Guile
1787 Integration.). On systems which support dynamically loadable objects,
1788 you can write your own extension in any language (which can be compiled
1789 into such an object) and load it to provide extended capabilities
1790 (*note The `load' Directive: load Directive.).
1794 * Guile Integration:: Using Guile as an embedded scripting language.
1795 * Loading Objects:: Loading dynamic objects as extensions.
1798 File: make.info, Node: Guile Integration, Next: Loading Objects, Prev: Extending make, Up: Extending make
1800 12.1 GNU Guile Integration
1801 ==========================
1803 GNU `make' may be built with support for GNU Guile as an embedded
1804 extension language. Guile implements the Scheme language. A review of
1805 GNU Guile and the Scheme language and its features is beyond the scope
1806 of this manual: see the documentation for GNU Guile and Scheme.
1808 You can determine if `make' contains support for Guile by examining
1809 the `.FEATURES' variable; it will contain the word GUILE if Guile
1810 support is available.
1812 The Guile integration provides one new `make' function: `guile'.
1813 The `guile' function takes one argument which is first expanded by
1814 `make' in the normal fashion, then passed to the GNU Guile evaluator.
1815 The result of the evaluator is converted into a string and used as the
1816 expansion of the `guile' function in the makefile.
1818 In addition, GNU `make' exposes Guile procedures for use in Guile
1823 * Guile Types:: Converting Guile types to `make' strings.
1824 * Guile Interface:: Invoking `make' functions from Guile.
1825 * Guile Example:: Example using Guile in `make'.
1828 File: make.info, Node: Guile Types, Next: Guile Interface, Prev: Guile Integration, Up: Guile Integration
1830 12.1.1 Conversion of Guile Types
1831 --------------------------------
1833 There is only one "data type" in `make': a string. GNU Guile, on the
1834 other hand, provides a rich variety of different data types. An
1835 important aspect of the interface between `make' and GNU Guile is the
1836 conversion of Guile data types into `make' strings.
1838 This conversion is relevant in two places: when a makefile invokes
1839 the `guile' function to evaluate a Guile expression, the result of that
1840 evaluation must be converted into a make string so it can be further
1841 evaluated by `make'. And secondly, when a Guile script invokes one of
1842 the procedures exported by `make' the argument provided to the
1843 procedure must be converted into a string.
1845 The conversion of Guile types into `make' strings is as below:
1848 False is converted into the empty string: in `make' conditionals
1849 the empty string is considered false.
1852 True is converted to the string `#t': in `make' conditionals any
1853 non-empty string is considered true.
1858 A symbol or number is converted into the string representation of
1859 that symbol or number.
1862 A printable character is converted to the same character.
1865 A string containing only printable characters is converted to the
1869 A list is converted recursively according to the above rules. This
1870 implies that any structured list will be flattened (that is, a
1871 result of `'(a b (c d) e)' will be converted to the `make' string
1875 Any other Guile type results in an error. In future versions of
1876 `make', other Guile types may be converted.
1879 The translation of `#f' (to the empty string) and `#t' (to the
1880 non-empty string `#t') is designed to allow you to use Guile boolean
1881 results directly as `make' boolean conditions. For example:
1883 $(if $(guile (access? "myfile" R_OK)),$(info myfile exists))
1885 As a consequence of these conversion rules you must consider the
1886 result of your Guile script, as that result will be converted into a
1887 string and parsed by `make'. If there is no natural result for the
1888 script (that is, the script exists solely for its side-effects), you
1889 should add `#f' as the final expression in order to avoid syntax errors
1893 File: make.info, Node: Guile Interface, Next: Guile Example, Prev: Guile Types, Up: Guile Integration
1895 12.1.2 Interfaces from Guile to `make'
1896 --------------------------------------
1898 In addition to the `guile' function available in makefiles, `make'
1899 exposes some procedures for use in your Guile scripts. At startup
1900 `make' creates a new Guile module, `gnu make', and exports these
1901 procedures as public interfaces from that module:
1904 This procedure takes a single argument which is converted into a
1905 string. The string is expanded by `make' using normal `make'
1906 expansion rules. The result of the expansion is converted into a
1907 Guile string and provided as the result of the procedure.
1910 This procedure takes a single argument which is converted into a
1911 string. The string is evaluated by `make' as if it were a
1912 makefile. This is the same capability available via the `eval'
1913 function (*note Eval Function::). The result of the `gmk-eval'
1914 procedure is always the empty string.
1916 Note that `gmk-eval' is not quite the same as using `gmk-expand'
1917 with the `eval' function: in the latter case the evaluated string
1918 will be expanded _twice_; first by `gmk-expand', then again by the
1923 File: make.info, Node: Guile Example, Prev: Guile Interface, Up: Guile Integration
1925 12.1.3 Example Using Guile in `make'
1926 ------------------------------------
1928 Here is a very simple example using GNU Guile to manage writing to a
1929 file. These Guile procedures simply open a file, allow writing to the
1930 file (one string per line), and close the file. Note that because we
1931 cannot store complex values such as Guile ports in `make' variables,
1932 we'll keep the port as a global variable in the Guile interpreter.
1934 You can create Guile functions easily using `define'/`endef' to
1935 create a Guile script, then use the `guile' function to internalize it:
1938 ;; A simple Guile IO library for GNU make
1942 (define (mkopen name mode)
1943 (set! MKPORT (open-file name mode))
1958 # Internalize the Guile IO functions
1961 If you have a significant amount of Guile support code, you might
1962 consider keeping it in a different file (e.g., `guileio.scm') and then
1963 loading it in your makefile using the `guile' function:
1965 $(guile (load "guileio.scm"))
1967 An advantage to this method is that when editing `guileio.scm', your
1968 editor will understand that this file contains Scheme syntax rather
1969 than makefile syntax.
1971 Now you can use these Guile functions to create files. Suppose you
1972 need to operate on a very large list, which cannot fit on the command
1973 line, but the utility you're using accepts the list as input as well:
1976 @$(guile (mkopen "tmp.out" "w")) \
1977 $(foreach X,$^,$(guile (mkwrite "$(X)"))) \
1981 A more comprehensive suite of file manipulation procedures is
1982 possible of course. You could, for example, maintain multiple output
1983 files at the same time by choosing a symbol for each one and using it
1984 as the key to a hash table, where the value is a port, then returning
1985 the symbol to be stored in a `make' variable.
1988 File: make.info, Node: Loading Objects, Prev: Guile Integration, Up: Extending make
1990 12.2 Loading Dynamic Objects
1991 ============================
1993 Warning: The `load' directive and extension capability is
1994 considered a "technology preview" in this release of GNU make. We
1995 encourage you to experiment with this feature and we appreciate
1996 any feedback on it. However we cannot guarantee to maintain
1997 backward-compatibility in the next release. Consider using GNU
1998 Guile instead for extending GNU make (*note The `guile' Function:
2001 Many operating systems provide a facility for dynamically loading
2002 compiled objects. If your system provides this facility, GNU `make'
2003 can make use of it to load dynamic objects at runtime, providing new
2004 capabilities which may then be invoked by your makefile.
2006 The `load' directive is used to load a dynamic object. Once the
2007 object is loaded, a "setup" function will be invoked to allow the
2008 object to initialize itself and register new facilities with GNU
2009 `make'. A dynamic object might include new `make' functions, for
2010 example, and the "setup" function would register them with GNU `make''s
2011 function handling system.
2015 * load Directive:: Loading dynamic objects as extensions.
2016 * Remaking Loaded Objects:: How loaded objects get remade.
2017 * Loaded Object API:: Programmatic interface for loaded objects.
2018 * Loaded Object Example:: Example of a loaded object
2021 File: make.info, Node: load Directive, Next: Remaking Loaded Objects, Prev: Loading Objects, Up: Loading Objects
2023 12.2.1 The `load' Directive
2024 ---------------------------
2026 Objects are loaded into GNU `make' by placing the `load' directive into
2027 your makefile. The syntax of the `load' directive is as follows:
2029 load OBJECT-FILE ...
2033 load OBJECT-FILE(SYMBOL-NAME) ...
2035 The file OBJECT-FILE is dynamically loaded by GNU `make'. If
2036 OBJECT-FILE does not include a directory path then it is first looked
2037 for in the current directory. If it is not found there, or a directory
2038 path is included, then system-specific paths will be searched. If the
2039 load fails for any reason, `make' will print a message and exit.
2041 If the load succeeds `make' will invoke an initializing function.
2043 If SYMBOL-NAME is provided, it will be used as the name of the
2044 initializing function.
2046 If no SYMBOL-NAME is provided, the initializing function name is
2047 created by taking the base file name of OBJECT-FILE, up to the first
2048 character which is not a valid symbol name character (alphanumerics and
2049 underscores are valid symbol name characters). To this prefix will be
2050 appended the suffix `_gmk_setup'.
2052 More than one object file may be loaded with a single `load'
2053 directive, and both forms of `load' arguments may be used in the same
2056 The initializing function will be provided the file name and line
2057 number of the invocation of the `load' operation. It should return a
2058 value of type `int', which must be `0' on failure and non-`0' on
2059 success. If the return value is `-1', then GNU make will _not_ attempt
2060 to rebuild the object file (*note How Loaded Objects Are Remade:
2061 Remaking Loaded Objects.).
2067 will load the dynamic object `../mk_funcs.so'. After the object is
2068 loaded, `make' will invoke the function (assumed to be defined by the
2069 shared object) `mk_funcs_gmk_setup'.
2073 load ../mk_funcs.so(init_mk_func)
2075 will load the dynamic object `../mk_funcs.so'. After the object is
2076 loaded, `make' will invoke the function `init_mk_func'.
2078 Regardless of how many times an object file appears in a `load'
2079 directive, it will only be loaded (and its setup function will only be
2082 After an object has been successfully loaded, its file name is
2083 appended to the `.LOADED' variable.
2085 If you would prefer that failure to load a dynamic object not be
2086 reported as an error, you can use the `-load' directive instead of
2087 `load'. GNU `make' will not fail and no message will be generated if
2088 an object fails to load. The failed object is not added to the
2089 `.LOADED' variable, which can then be consulted to determine if the
2090 load was successful.
2093 File: make.info, Node: Remaking Loaded Objects, Next: Loaded Object API, Prev: load Directive, Up: Loading Objects
2095 12.2.2 How Loaded Objects Are Remade
2096 ------------------------------------
2098 Loaded objects undergo the same re-make procedure as makefiles (*note
2099 How Makefiles Are Remade: Remaking Makefiles.). If any loaded object
2100 is recreated, then `make' will start from scratch and re-read all the
2101 makefiles, and reload the object files again. It is not necessary for
2102 the loaded object to do anything special to support this.
2104 It's up to the makefile author to provide the rules needed for
2105 rebuilding the loaded object.
2108 File: make.info, Node: Loaded Object API, Next: Loaded Object Example, Prev: Remaking Loaded Objects, Up: Loading Objects
2110 12.2.3 Loaded Object Interface
2111 ------------------------------
2113 Warning: For this feature to be useful your extensions will need
2114 to invoke various functions internal to GNU `make'. The
2115 programming interfaces provided in this release should not be
2116 considered stable: functions may be added, removed, or change
2117 calling signatures or implementations in future versions of GNU
2120 To be useful, loaded objects must be able to interact with GNU `make'.
2121 This interaction includes both interfaces the loaded object provides to
2122 makefiles and also interfaces `make' provides to the loaded object to
2123 manipulate `make''s operation.
2125 The interface between loaded objects and `make' is defined by the
2126 `gnumake.h' C header file. All loaded objects written in C should
2127 include this header file. Any loaded object not written in C will need
2128 to implement the interface defined in this header file.
2130 Typically, a loaded object will register one or more new GNU `make'
2131 functions using the `gmk_add_function' routine from within its setup
2132 function. The implementations of these `make' functions may make use
2133 of the `gmk_expand' and `gmk_eval' routines to perform their tasks,
2134 then optionally return a string as the result of the function expansion.
2136 Loaded Object Licensing
2137 .......................
2139 Every dynamic extension should define the global symbol
2140 `plugin_is_GPL_compatible' to assert that it has been licensed under a
2141 GPL-compatible license. If this symbol does not exist, `make' emits a
2142 fatal error and exits when it tries to load your extension.
2144 The declared type of the symbol should be `int'. It does not need to
2145 be in any allocated section, though. The code merely asserts that the
2146 symbol exists in the global scope. Something like this is enough:
2148 int plugin_is_GPL_compatible;
2154 This structure represents a filename/location pair. It is provided
2155 when defining items, so GNU `make' can inform the user later where
2156 the definition occurred if necessary.
2158 Registering Functions
2159 .....................
2161 There is currently one way for makefiles to invoke operations provided
2162 by the loaded object: through the `make' function call interface. A
2163 loaded object can register one or more new functions which may then be
2164 invoked from within the makefile in the same way as any other function.
2166 Use `gmk_add_function' to create a new `make' function. Its
2167 arguments are as follows:
2170 The function name. This is what the makefile should use to invoke
2171 the function. The name must be between 1 and 255 characters long
2172 and it may only contain alphanumeric, period (`.'), dash (`-'), and
2173 underscore (`_') characters. It may not begin with a period.
2176 A pointer to a function that `make' will invoke when it expands
2177 the function in a makefile. This function must be defined by the
2181 The minimum number of arguments the function will accept. Must be
2182 between 0 and 255. GNU `make' will check this and fail before
2183 invoking `func_ptr' if the function was invoked with too few
2187 The maximum number of arguments the function will accept. Must be
2188 between 0 and 255. GNU `make' will check this and fail before
2189 invoking `func_ptr' if the function was invoked with too few
2190 arguments. If the value is 0, then any number of arguments is
2191 accepted. If the value is greater than 0, then it must be greater
2192 than or equal to `min_args'.
2195 Flags that specify how this function will operate; the desired
2196 flags should be OR'd together. If the `GMK_FUNC_NOEXPAND' flag is
2197 given then the function arguments will not be expanded before the
2198 function is called; otherwise they will be expanded first.
2200 Registered Function Interface
2201 .............................
2203 A function registered with `make' must match the `gmk_func_ptr' type.
2204 It will be invoked with three parameters: `name' (the name of the
2205 function), `argc' (the number of arguments to the function), and `argv'
2206 (an array of pointers to arguments to the function). The last pointer
2207 (that is, `argv[argc]') will be null (`0').
2209 The return value of the function is the result of expanding the
2210 function. If the function expands to nothing the return value may be
2211 null. Otherwise, it must be a pointer to a string created with
2212 `gmk_alloc'. Once the function returns, `make' owns this string and
2213 will free it when appropriate; it cannot be accessed by the loaded
2216 GNU `make' Facilities
2217 .....................
2219 There are some facilities exported by GNU `make' for use by loaded
2220 objects. Typically these would be run from within the setup function
2221 and/or the functions registered via `gmk_add_function', to retrieve or
2222 modify the data `make' works with.
2225 This function takes a string and expands it using `make' expansion
2226 rules. The result of the expansion is returned in a
2227 nil-terminated string buffer. The caller is responsible for
2228 calling `gmk_free' with a pointer to the returned buffer when done.
2231 This function takes a buffer and evaluates it as a segment of
2232 makefile syntax. This function can be used to define new
2233 variables, new rules, etc. It is equivalent to using the `eval'
2236 Note that there is a difference between `gmk_eval' and calling
2237 `gmk_expand' with a string using the `eval' function: in the latter
2238 case the string will be expanded _twice_; once by `gmk_expand' and then
2239 again by the `eval' function. Using `gmk_eval' the buffer is only
2240 expanded once, at most (as it's read by the `make' parser).
2245 Some systems allow for different memory management schemes. Thus you
2246 should never pass memory that you've allocated directly to any `make'
2247 function, nor should you attempt to directly free any memory returned
2248 to you by any `make' function. Instead, use the `gmk_alloc' and
2249 `gmk_free' functions.
2251 In particular, the string returned to `make' by a function
2252 registered using `gmk_add_function' _must_ be allocated using
2253 `gmk_alloc', and the string returned from the `make' `gmk_expand'
2254 function _must_ be freed (when no longer needed) using `gmk_free'.
2257 Return a pointer to a newly-allocated buffer. This function will
2258 always return a valid pointer; if not enough memory is available
2262 Free a buffer returned to you by `make'. Once the `gmk_free'
2263 function returns the string will no longer be valid.
2266 File: make.info, Node: Loaded Object Example, Prev: Loaded Object API, Up: Loading Objects
2268 12.2.4 Example Loaded Object
2269 ----------------------------
2271 Let's suppose we wanted to write a new GNU `make' function that would
2272 create a temporary file and return its name. We would like our
2273 function to take a prefix as an argument. First we can write the
2274 function in a file `mk_temp.c':
2283 #include <gnumake.h>
2285 int plugin_is_GPL_compatible;
2288 gen_tmpfile(const char *nm, int argc, char **argv)
2292 /* Compute the size of the filename and allocate space for it. */
2293 int len = strlen (argv[0]) + 6 + 1;
2294 char *buf = gmk_alloc (len);
2296 strcpy (buf, argv[0]);
2297 strcat (buf, "XXXXXX");
2302 /* Don't leak the file descriptor. */
2308 fprintf (stderr, "mkstemp(%s) failed: %s\n", buf, strerror (errno));
2314 mk_temp_gmk_setup ()
2316 /* Register the function with make name "mk-temp". */
2317 gmk_add_function ("mk-temp", gen_tmpfile, 1, 1, 1);
2321 Next, we will write a makefile that can build this shared object,
2322 load it, and use it:
2325 @echo Temporary file: $(mk-temp tmpfile.)
2329 mk_temp.so: mk_temp.c
2330 $(CC) -shared -fPIC -o $ $<
2332 On MS-Windows, due to peculiarities of how shared objects are
2333 produced, the compiler needs to scan the "import library" produced when
2334 building `make', typically called `libgnumake-VERSION.dll.a', where
2335 VERSION is the version of the load object API. So the recipe to
2336 produce a shared object will look on Windows like this (assuming the
2339 mk_temp.dll: mk_temp.c
2340 $(CC) -shared -o $ $< -lgnumake-1
2342 Now when you run `make' you'll see something like:
2345 cc -shared -fPIC -o mk_temp.so mk_temp.c
2346 Temporary filename: tmpfile.A7JEwd
2349 File: make.info, Node: Features, Next: Missing, Prev: Extending make, Up: Top
2351 13 Features of GNU `make'
2352 *************************
2354 Here is a summary of the features of GNU `make', for comparison with
2355 and credit to other versions of `make'. We consider the features of
2356 `make' in 4.2 BSD systems as a baseline. If you are concerned with
2357 writing portable makefiles, you should not use the features of `make'
2358 listed here, nor the ones in *note Missing::.
2360 Many features come from the version of `make' in System V.
2362 * The `VPATH' variable and its special meaning. *Note Searching
2363 Directories for Prerequisites: Directory Search. This feature
2364 exists in System V `make', but is undocumented. It is documented
2365 in 4.3 BSD `make' (which says it mimics System V's `VPATH'
2368 * Included makefiles. *Note Including Other Makefiles: Include.
2369 Allowing multiple files to be included with a single directive is
2372 * Variables are read from and communicated via the environment.
2373 *Note Variables from the Environment: Environment.
2375 * Options passed through the variable `MAKEFLAGS' to recursive
2376 invocations of `make'. *Note Communicating Options to a
2377 Sub-`make': Options/Recursion.
2379 * The automatic variable `$%' is set to the member name in an
2380 archive reference. *Note Automatic Variables::.
2382 * The automatic variables `$@', `$*', `$<', `$%', and `$?' have
2383 corresponding forms like `$(@F)' and `$(@D)'. We have generalized
2384 this to `$^' as an obvious extension. *Note Automatic Variables::.
2386 * Substitution variable references. *Note Basics of Variable
2387 References: Reference.
2389 * The command line options `-b' and `-m', accepted and ignored. In
2390 System V `make', these options actually do something.
2392 * Execution of recursive commands to run `make' via the variable
2393 `MAKE' even if `-n', `-q' or `-t' is specified. *Note Recursive
2394 Use of `make': Recursion.
2396 * Support for suffix `.a' in suffix rules. *Note Archive Suffix
2397 Rules::. This feature is obsolete in GNU `make', because the
2398 general feature of rule chaining (*note Chains of Implicit Rules:
2399 Chained Rules.) allows one pattern rule for installing members in
2400 an archive (*note Archive Update::) to be sufficient.
2402 * The arrangement of lines and backslash/newline combinations in
2403 recipes is retained when the recipes are printed, so they appear as
2404 they do in the makefile, except for the stripping of initial
2407 The following features were inspired by various other versions of
2408 `make'. In some cases it is unclear exactly which versions inspired
2411 * Pattern rules using `%'. This has been implemented in several
2412 versions of `make'. We're not sure who invented it first, but
2413 it's been spread around a bit. *Note Defining and Redefining
2414 Pattern Rules: Pattern Rules.
2416 * Rule chaining and implicit intermediate files. This was
2417 implemented by Stu Feldman in his version of `make' for AT&T
2418 Eighth Edition Research Unix, and later by Andrew Hume of AT&T
2419 Bell Labs in his `mk' program (where he terms it "transitive
2420 closure"). We do not really know if we got this from either of
2421 them or thought it up ourselves at the same time. *Note Chains of
2422 Implicit Rules: Chained Rules.
2424 * The automatic variable `$^' containing a list of all prerequisites
2425 of the current target. We did not invent this, but we have no
2426 idea who did. *Note Automatic Variables::. The automatic variable
2427 `$+' is a simple extension of `$^'.
2429 * The "what if" flag (`-W' in GNU `make') was (as far as we know)
2430 invented by Andrew Hume in `mk'. *Note Instead of Executing
2431 Recipes: Instead of Execution.
2433 * The concept of doing several things at once (parallelism) exists in
2434 many incarnations of `make' and similar programs, though not in the
2435 System V or BSD implementations. *Note Recipe Execution:
2438 * A number of different build tools that support parallelism also
2439 support collecting output and displaying as a single block. *Note
2440 Output During Parallel Execution: Parallel Output.
2442 * Modified variable references using pattern substitution come from
2443 SunOS 4. *Note Basics of Variable References: Reference. This
2444 functionality was provided in GNU `make' by the `patsubst'
2445 function before the alternate syntax was implemented for
2446 compatibility with SunOS 4. It is not altogether clear who
2447 inspired whom, since GNU `make' had `patsubst' before SunOS 4 was
2450 * The special significance of `+' characters preceding recipe lines
2451 (*note Instead of Executing Recipes: Instead of Execution.) is
2452 mandated by `IEEE Standard 1003.2-1992' (POSIX.2).
2454 * The `+=' syntax to append to the value of a variable comes from
2455 SunOS 4 `make'. *Note Appending More Text to Variables: Appending.
2457 * The syntax `ARCHIVE(MEM1 MEM2...)' to list multiple members in a
2458 single archive file comes from SunOS 4 `make'. *Note Archive
2461 * The `-include' directive to include makefiles with no error for a
2462 nonexistent file comes from SunOS 4 `make'. (But note that SunOS 4
2463 `make' does not allow multiple makefiles to be specified in one
2464 `-include' directive.) The same feature appears with the name
2465 `sinclude' in SGI `make' and perhaps others.
2467 * The `!=' shell assignment operator exists in many BSD of `make'
2468 and is purposefully implemented here to behave identically to
2469 those implementations.
2471 * Various build management tools are implemented using scripting
2472 languages such as Perl or Python and thus provide a natural
2473 embedded scripting language, similar to GNU `make''s integration
2476 The remaining features are inventions new in GNU `make':
2478 * Use the `-v' or `--version' option to print version and copyright
2481 * Use the `-h' or `--help' option to summarize the options to `make'.
2483 * Simply-expanded variables. *Note The Two Flavors of Variables:
2486 * Pass command line variable assignments automatically through the
2487 variable `MAKE' to recursive `make' invocations. *Note Recursive
2488 Use of `make': Recursion.
2490 * Use the `-C' or `--directory' command option to change directory.
2491 *Note Summary of Options: Options Summary.
2493 * Make verbatim variable definitions with `define'. *Note Defining
2494 Multi-Line Variables: Multi-Line.
2496 * Declare phony targets with the special target `.PHONY'.
2498 Andrew Hume of AT&T Bell Labs implemented a similar feature with a
2499 different syntax in his `mk' program. This seems to be a case of
2500 parallel discovery. *Note Phony Targets: Phony Targets.
2502 * Manipulate text by calling functions. *Note Functions for
2503 Transforming Text: Functions.
2505 * Use the `-o' or `--old-file' option to pretend a file's
2506 modification-time is old. *Note Avoiding Recompilation of Some
2507 Files: Avoiding Compilation.
2509 * Conditional execution.
2511 This feature has been implemented numerous times in various
2512 versions of `make'; it seems a natural extension derived from the
2513 features of the C preprocessor and similar macro languages and is
2514 not a revolutionary concept. *Note Conditional Parts of
2515 Makefiles: Conditionals.
2517 * Specify a search path for included makefiles. *Note Including
2518 Other Makefiles: Include.
2520 * Specify extra makefiles to read with an environment variable.
2521 *Note The Variable `MAKEFILES': MAKEFILES Variable.
2523 * Strip leading sequences of `./' from file names, so that `./FILE'
2524 and `FILE' are considered to be the same file.
2526 * Use a special search method for library prerequisites written in
2527 the form `-lNAME'. *Note Directory Search for Link Libraries:
2530 * Allow suffixes for suffix rules (*note Old-Fashioned Suffix Rules:
2531 Suffix Rules.) to contain any characters. In other versions of
2532 `make', they must begin with `.' and not contain any `/'
2535 * Keep track of the current level of `make' recursion using the
2536 variable `MAKELEVEL'. *Note Recursive Use of `make': Recursion.
2538 * Provide any goals given on the command line in the variable
2539 `MAKECMDGOALS'. *Note Arguments to Specify the Goals: Goals.
2541 * Specify static pattern rules. *Note Static Pattern Rules: Static
2544 * Provide selective `vpath' search. *Note Searching Directories for
2545 Prerequisites: Directory Search.
2547 * Provide computed variable references. *Note Basics of Variable
2548 References: Reference.
2550 * Update makefiles. *Note How Makefiles Are Remade: Remaking
2551 Makefiles. System V `make' has a very, very limited form of this
2552 functionality in that it will check out SCCS files for makefiles.
2554 * Various new built-in implicit rules. *Note Catalogue of Implicit
2555 Rules: Catalogue of Rules.
2557 * Load dynamic objects which can modify the behavior of `make'.
2558 *Note Loading Dynamic Objects: Loading Objects.
2561 File: make.info, Node: Missing, Next: Makefile Conventions, Prev: Features, Up: Top
2563 14 Incompatibilities and Missing Features
2564 *****************************************
2566 The `make' programs in various other systems support a few features
2567 that are not implemented in GNU `make'. The POSIX.2 standard (`IEEE
2568 Standard 1003.2-1992') which specifies `make' does not require any of
2571 * A target of the form `FILE((ENTRY))' stands for a member of
2572 archive file FILE. The member is chosen, not by name, but by
2573 being an object file which defines the linker symbol ENTRY.
2575 This feature was not put into GNU `make' because of the
2576 non-modularity of putting knowledge into `make' of the internal
2577 format of archive file symbol tables. *Note Updating Archive
2578 Symbol Directories: Archive Symbols.
2580 * Suffixes (used in suffix rules) that end with the character `~'
2581 have a special meaning to System V `make'; they refer to the SCCS
2582 file that corresponds to the file one would get without the `~'.
2583 For example, the suffix rule `.c~.o' would make the file `N.o' from
2584 the SCCS file `s.N.c'. For complete coverage, a whole series of
2585 such suffix rules is required. *Note Old-Fashioned Suffix Rules:
2588 In GNU `make', this entire series of cases is handled by two
2589 pattern rules for extraction from SCCS, in combination with the
2590 general feature of rule chaining. *Note Chains of Implicit Rules:
2593 * In System V and 4.3 BSD `make', files found by `VPATH' search
2594 (*note Searching Directories for Prerequisites: Directory Search.)
2595 have their names changed inside recipes. We feel it is much
2596 cleaner to always use automatic variables and thus make this
2599 * In some Unix `make's, the automatic variable `$*' appearing in the
2600 prerequisites of a rule has the amazingly strange "feature" of
2601 expanding to the full name of the _target of that rule_. We cannot
2602 imagine what went on in the minds of Unix `make' developers to do
2603 this; it is utterly inconsistent with the normal definition of
2606 * In some Unix `make's, implicit rule search (*note Using Implicit
2607 Rules: Implicit Rules.) is apparently done for _all_ targets, not
2608 just those without recipes. This means you can do:
2613 and Unix `make' will intuit that `foo.o' depends on `foo.c'.
2615 We feel that such usage is broken. The prerequisite properties of
2616 `make' are well-defined (for GNU `make', at least), and doing such
2617 a thing simply does not fit the model.
2619 * GNU `make' does not include any built-in implicit rules for
2620 compiling or preprocessing EFL programs. If we hear of anyone who
2621 is using EFL, we will gladly add them.
2623 * It appears that in SVR4 `make', a suffix rule can be specified
2624 with no recipe, and it is treated as if it had an empty recipe
2625 (*note Empty Recipes::). For example:
2629 will override the built-in `.c.a' suffix rule.
2631 We feel that it is cleaner for a rule without a recipe to always
2632 simply add to the prerequisite list for the target. The above
2633 example can be easily rewritten to get the desired behavior in GNU
2638 * Some versions of `make' invoke the shell with the `-e' flag,
2639 except under `-k' (*note Testing the Compilation of a Program:
2640 Testing.). The `-e' flag tells the shell to exit as soon as any
2641 program it runs returns a nonzero status. We feel it is cleaner to
2642 write each line of the recipe to stand on its own and not require
2643 this special treatment.
2646 File: make.info, Node: Makefile Conventions, Next: Quick Reference, Prev: Missing, Up: Top
2648 15 Makefile Conventions
2649 ***********************
2651 This node describes conventions for writing the Makefiles for GNU
2652 programs. Using Automake will help you write a Makefile that follows
2653 these conventions. For more information on portable Makefiles, see
2654 POSIX and *note Portable Make Programming: (autoconf)Portable Make.
2658 * Makefile Basics:: General conventions for Makefiles.
2659 * Utilities in Makefiles:: Utilities to be used in Makefiles.
2660 * Command Variables:: Variables for specifying commands.
2661 * DESTDIR:: Supporting staged installs.
2662 * Directory Variables:: Variables for installation directories.
2663 * Standard Targets:: Standard targets for users.
2664 * Install Command Categories:: Three categories of commands in the `install'
2665 rule: normal, pre-install and post-install.
2668 File: make.info, Node: Makefile Basics, Next: Utilities in Makefiles, Up: Makefile Conventions
2670 15.1 General Conventions for Makefiles
2671 ======================================
2673 Every Makefile should contain this line:
2677 to avoid trouble on systems where the `SHELL' variable might be
2678 inherited from the environment. (This is never a problem with GNU
2681 Different `make' programs have incompatible suffix lists and
2682 implicit rules, and this sometimes creates confusion or misbehavior. So
2683 it is a good idea to set the suffix list explicitly using only the
2684 suffixes you need in the particular Makefile, like this:
2689 The first line clears out the suffix list, the second introduces all
2690 suffixes which may be subject to implicit rules in this Makefile.
2692 Don't assume that `.' is in the path for command execution. When
2693 you need to run programs that are a part of your package during the
2694 make, please make sure that it uses `./' if the program is built as
2695 part of the make or `$(srcdir)/' if the file is an unchanging part of
2696 the source code. Without one of these prefixes, the current search
2699 The distinction between `./' (the "build directory") and
2700 `$(srcdir)/' (the "source directory") is important because users can
2701 build in a separate directory using the `--srcdir' option to
2702 `configure'. A rule of the form:
2704 foo.1 : foo.man sedscript
2705 sed -f sedscript foo.man > foo.1
2707 will fail when the build directory is not the source directory, because
2708 `foo.man' and `sedscript' are in the source directory.
2710 When using GNU `make', relying on `VPATH' to find the source file
2711 will work in the case where there is a single dependency file, since
2712 the `make' automatic variable `$<' will represent the source file
2713 wherever it is. (Many versions of `make' set `$<' only in implicit
2714 rules.) A Makefile target like
2717 $(CC) -I. -I$(srcdir) $(CFLAGS) -c bar.c -o foo.o
2719 should instead be written as
2722 $(CC) -I. -I$(srcdir) $(CFLAGS) -c $< -o $@
2724 in order to allow `VPATH' to work correctly. When the target has
2725 multiple dependencies, using an explicit `$(srcdir)' is the easiest way
2726 to make the rule work well. For example, the target above for `foo.1'
2729 foo.1 : foo.man sedscript
2730 sed -f $(srcdir)/sedscript $(srcdir)/foo.man > $@
2732 GNU distributions usually contain some files which are not source
2733 files--for example, Info files, and the output from Autoconf, Automake,
2734 Bison or Flex. Since these files normally appear in the source
2735 directory, they should always appear in the source directory, not in the
2736 build directory. So Makefile rules to update them should put the
2737 updated files in the source directory.
2739 However, if a file does not appear in the distribution, then the
2740 Makefile should not put it in the source directory, because building a
2741 program in ordinary circumstances should not modify the source directory
2744 Try to make the build and installation targets, at least (and all
2745 their subtargets) work correctly with a parallel `make'.
2748 File: make.info, Node: Utilities in Makefiles, Next: Command Variables, Prev: Makefile Basics, Up: Makefile Conventions
2750 15.2 Utilities in Makefiles
2751 ===========================
2753 Write the Makefile commands (and any shell scripts, such as
2754 `configure') to run under `sh' (both the traditional Bourne shell and
2755 the POSIX shell), not `csh'. Don't use any special features of `ksh'
2756 or `bash', or POSIX features not widely supported in traditional Bourne
2759 The `configure' script and the Makefile rules for building and
2760 installation should not use any utilities directly except these:
2762 awk cat cmp cp diff echo egrep expr false grep install-info ln ls
2763 mkdir mv printf pwd rm rmdir sed sleep sort tar test touch tr true
2765 Compression programs such as `gzip' can be used in the `dist' rule.
2767 Generally, stick to the widely-supported (usually POSIX-specified)
2768 options and features of these programs. For example, don't use `mkdir
2769 -p', convenient as it may be, because a few systems don't support it at
2770 all and with others, it is not safe for parallel execution. For a list
2771 of known incompatibilities, see *note Portable Shell Programming:
2772 (autoconf)Portable Shell.
2774 It is a good idea to avoid creating symbolic links in makefiles,
2775 since a few file systems don't support them.
2777 The Makefile rules for building and installation can also use
2778 compilers and related programs, but should do so via `make' variables
2779 so that the user can substitute alternatives. Here are some of the
2782 ar bison cc flex install ld ldconfig lex
2783 make makeinfo ranlib texi2dvi yacc
2785 Use the following `make' variables to run those programs:
2787 $(AR) $(BISON) $(CC) $(FLEX) $(INSTALL) $(LD) $(LDCONFIG) $(LEX)
2788 $(MAKE) $(MAKEINFO) $(RANLIB) $(TEXI2DVI) $(YACC)
2790 When you use `ranlib' or `ldconfig', you should make sure nothing
2791 bad happens if the system does not have the program in question.
2792 Arrange to ignore an error from that command, and print a message before
2793 the command to tell the user that failure of this command does not mean
2794 a problem. (The Autoconf `AC_PROG_RANLIB' macro can help with this.)
2796 If you use symbolic links, you should implement a fallback for
2797 systems that don't have symbolic links.
2799 Additional utilities that can be used via Make variables are:
2801 chgrp chmod chown mknod
2803 It is ok to use other utilities in Makefile portions (or scripts)
2804 intended only for particular systems where you know those utilities
2808 File: make.info, Node: Command Variables, Next: DESTDIR, Prev: Utilities in Makefiles, Up: Makefile Conventions
2810 15.3 Variables for Specifying Commands
2811 ======================================
2813 Makefiles should provide variables for overriding certain commands,
2816 In particular, you should run most utility programs via variables.
2817 Thus, if you use Bison, have a variable named `BISON' whose default
2818 value is set with `BISON = bison', and refer to it with `$(BISON)'
2819 whenever you need to use Bison.
2821 File management utilities such as `ln', `rm', `mv', and so on, need
2822 not be referred to through variables in this way, since users don't
2823 need to replace them with other programs.
2825 Each program-name variable should come with an options variable that
2826 is used to supply options to the program. Append `FLAGS' to the
2827 program-name variable name to get the options variable name--for
2828 example, `BISONFLAGS'. (The names `CFLAGS' for the C compiler,
2829 `YFLAGS' for yacc, and `LFLAGS' for lex, are exceptions to this rule,
2830 but we keep them because they are standard.) Use `CPPFLAGS' in any
2831 compilation command that runs the preprocessor, and use `LDFLAGS' in
2832 any compilation command that does linking as well as in any direct use
2835 If there are C compiler options that _must_ be used for proper
2836 compilation of certain files, do not include them in `CFLAGS'. Users
2837 expect to be able to specify `CFLAGS' freely themselves. Instead,
2838 arrange to pass the necessary options to the C compiler independently
2839 of `CFLAGS', by writing them explicitly in the compilation commands or
2840 by defining an implicit rule, like this:
2843 ALL_CFLAGS = -I. $(CFLAGS)
2845 $(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $<
2847 Do include the `-g' option in `CFLAGS', because that is not
2848 _required_ for proper compilation. You can consider it a default that
2849 is only recommended. If the package is set up so that it is compiled
2850 with GCC by default, then you might as well include `-O' in the default
2851 value of `CFLAGS' as well.
2853 Put `CFLAGS' last in the compilation command, after other variables
2854 containing compiler options, so the user can use `CFLAGS' to override
2857 `CFLAGS' should be used in every invocation of the C compiler, both
2858 those which do compilation and those which do linking.
2860 Every Makefile should define the variable `INSTALL', which is the
2861 basic command for installing a file into the system.
2863 Every Makefile should also define the variables `INSTALL_PROGRAM'
2864 and `INSTALL_DATA'. (The default for `INSTALL_PROGRAM' should be
2865 `$(INSTALL)'; the default for `INSTALL_DATA' should be `${INSTALL} -m
2866 644'.) Then it should use those variables as the commands for actual
2867 installation, for executables and non-executables respectively.
2868 Minimal use of these variables is as follows:
2870 $(INSTALL_PROGRAM) foo $(bindir)/foo
2871 $(INSTALL_DATA) libfoo.a $(libdir)/libfoo.a
2873 However, it is preferable to support a `DESTDIR' prefix on the
2874 target files, as explained in the next section.
2876 It is acceptable, but not required, to install multiple files in one
2877 command, with the final argument being a directory, as in:
2879 $(INSTALL_PROGRAM) foo bar baz $(bindir)
2882 File: make.info, Node: DESTDIR, Next: Directory Variables, Prev: Command Variables, Up: Makefile Conventions
2884 15.4 `DESTDIR': Support for Staged Installs
2885 ===========================================
2887 `DESTDIR' is a variable prepended to each installed target file, like
2890 $(INSTALL_PROGRAM) foo $(DESTDIR)$(bindir)/foo
2891 $(INSTALL_DATA) libfoo.a $(DESTDIR)$(libdir)/libfoo.a
2893 The `DESTDIR' variable is specified by the user on the `make'
2894 command line as an absolute file name. For example:
2896 make DESTDIR=/tmp/stage install
2898 `DESTDIR' should be supported only in the `install*' and `uninstall*'
2899 targets, as those are the only targets where it is useful.
2901 If your installation step would normally install
2902 `/usr/local/bin/foo' and `/usr/local/lib/libfoo.a', then an
2903 installation invoked as in the example above would install
2904 `/tmp/stage/usr/local/bin/foo' and `/tmp/stage/usr/local/lib/libfoo.a'
2907 Prepending the variable `DESTDIR' to each target in this way
2908 provides for "staged installs", where the installed files are not
2909 placed directly into their expected location but are instead copied
2910 into a temporary location (`DESTDIR'). However, installed files
2911 maintain their relative directory structure and any embedded file names
2912 will not be modified.
2914 You should not set the value of `DESTDIR' in your `Makefile' at all;
2915 then the files are installed into their expected locations by default.
2916 Also, specifying `DESTDIR' should not change the operation of the
2917 software in any way, so its value should not be included in any file
2920 `DESTDIR' support is commonly used in package creation. It is also
2921 helpful to users who want to understand what a given package will
2922 install where, and to allow users who don't normally have permissions
2923 to install into protected areas to build and install before gaining
2924 those permissions. Finally, it can be useful with tools such as
2925 `stow', where code is installed in one place but made to appear to be
2926 installed somewhere else using symbolic links or special mount
2927 operations. So, we strongly recommend GNU packages support `DESTDIR',
2928 though it is not an absolute requirement.
2931 File: make.info, Node: Directory Variables, Next: Standard Targets, Prev: DESTDIR, Up: Makefile Conventions
2933 15.5 Variables for Installation Directories
2934 ===========================================
2936 Installation directories should always be named by variables, so it is
2937 easy to install in a nonstandard place. The standard names for these
2938 variables and the values they should have in GNU packages are described
2939 below. They are based on a standard file system layout; variants of it
2940 are used in GNU/Linux and other modern operating systems.
2942 Installers are expected to override these values when calling `make'
2943 (e.g., `make prefix=/usr install' or `configure' (e.g., `configure
2944 --prefix=/usr'). GNU packages should not try to guess which value
2945 should be appropriate for these variables on the system they are being
2946 installed onto: use the default settings specified here so that all GNU
2947 packages behave identically, allowing the installer to achieve any
2950 All installation directories, and their parent directories, should be
2951 created (if necessary) before they are installed into.
2953 These first two variables set the root for the installation. All the
2954 other installation directories should be subdirectories of one of these
2955 two, and nothing should be directly installed into these two
2959 A prefix used in constructing the default values of the variables
2960 listed below. The default value of `prefix' should be
2961 `/usr/local'. When building the complete GNU system, the prefix
2962 will be empty and `/usr' will be a symbolic link to `/'. (If you
2963 are using Autoconf, write it as `@prefix@'.)
2965 Running `make install' with a different value of `prefix' from the
2966 one used to build the program should _not_ recompile the program.
2969 A prefix used in constructing the default values of some of the
2970 variables listed below. The default value of `exec_prefix' should
2971 be `$(prefix)'. (If you are using Autoconf, write it as
2974 Generally, `$(exec_prefix)' is used for directories that contain
2975 machine-specific files (such as executables and subroutine
2976 libraries), while `$(prefix)' is used directly for other
2979 Running `make install' with a different value of `exec_prefix'
2980 from the one used to build the program should _not_ recompile the
2983 Executable programs are installed in one of the following
2987 The directory for installing executable programs that users can
2988 run. This should normally be `/usr/local/bin', but write it as
2989 `$(exec_prefix)/bin'. (If you are using Autoconf, write it as
2993 The directory for installing executable programs that can be run
2994 from the shell, but are only generally useful to system
2995 administrators. This should normally be `/usr/local/sbin', but
2996 write it as `$(exec_prefix)/sbin'. (If you are using Autoconf,
2997 write it as `@sbindir@'.)
3000 The directory for installing executable programs to be run by other
3001 programs rather than by users. This directory should normally be
3002 `/usr/local/libexec', but write it as `$(exec_prefix)/libexec'.
3003 (If you are using Autoconf, write it as `@libexecdir@'.)
3005 The definition of `libexecdir' is the same for all packages, so
3006 you should install your data in a subdirectory thereof. Most
3007 packages install their data under `$(libexecdir)/PACKAGE-NAME/',
3008 possibly within additional subdirectories thereof, such as
3009 `$(libexecdir)/PACKAGE-NAME/MACHINE/VERSION'.
3011 Data files used by the program during its execution are divided into
3012 categories in two ways.
3014 * Some files are normally modified by programs; others are never
3015 normally modified (though users may edit some of these).
3017 * Some files are architecture-independent and can be shared by all
3018 machines at a site; some are architecture-dependent and can be
3019 shared only by machines of the same kind and operating system;
3020 others may never be shared between two machines.
3022 This makes for six different possibilities. However, we want to
3023 discourage the use of architecture-dependent files, aside from object
3024 files and libraries. It is much cleaner to make other data files
3025 architecture-independent, and it is generally not hard.
3027 Here are the variables Makefiles should use to specify directories
3028 to put these various kinds of files in:
3031 The root of the directory tree for read-only
3032 architecture-independent data files. This should normally be
3033 `/usr/local/share', but write it as `$(prefix)/share'. (If you
3034 are using Autoconf, write it as `@datarootdir@'.) `datadir''s
3035 default value is based on this variable; so are `infodir',
3036 `mandir', and others.
3039 The directory for installing idiosyncratic read-only
3040 architecture-independent data files for this program. This is
3041 usually the same place as `datarootdir', but we use the two
3042 separate variables so that you can move these program-specific
3043 files without altering the location for Info files, man pages, etc.
3045 This should normally be `/usr/local/share', but write it as
3046 `$(datarootdir)'. (If you are using Autoconf, write it as
3049 The definition of `datadir' is the same for all packages, so you
3050 should install your data in a subdirectory thereof. Most packages
3051 install their data under `$(datadir)/PACKAGE-NAME/'.
3054 The directory for installing read-only data files that pertain to a
3055 single machine-that is to say, files for configuring a host.
3056 Mailer and network configuration files, `/etc/passwd', and so
3057 forth belong here. All the files in this directory should be
3058 ordinary ASCII text files. This directory should normally be
3059 `/usr/local/etc', but write it as `$(prefix)/etc'. (If you are
3060 using Autoconf, write it as `@sysconfdir@'.)
3062 Do not install executables here in this directory (they probably
3063 belong in `$(libexecdir)' or `$(sbindir)'). Also do not install
3064 files that are modified in the normal course of their use (programs
3065 whose purpose is to change the configuration of the system
3066 excluded). Those probably belong in `$(localstatedir)'.
3069 The directory for installing architecture-independent data files
3070 which the programs modify while they run. This should normally be
3071 `/usr/local/com', but write it as `$(prefix)/com'. (If you are
3072 using Autoconf, write it as `@sharedstatedir@'.)
3075 The directory for installing data files which the programs modify
3076 while they run, and that pertain to one specific machine. Users
3077 should never need to modify files in this directory to configure
3078 the package's operation; put such configuration information in
3079 separate files that go in `$(datadir)' or `$(sysconfdir)'.
3080 `$(localstatedir)' should normally be `/usr/local/var', but write
3081 it as `$(prefix)/var'. (If you are using Autoconf, write it as
3085 The directory for installing data files which the programs modify
3086 while they run, that pertain to one specific machine, and which
3087 need not persist longer than the execution of the program--which is
3088 generally long-lived, for example, until the next reboot. PID
3089 files for system daemons are a typical use. In addition, this
3090 directory should not be cleaned except perhaps at reboot, while
3091 the general `/tmp' (`TMPDIR') may be cleaned arbitrarily. This
3092 should normally be `/var/run', but write it as
3093 `$(localstatedir)/run'. Having it as a separate variable allows
3094 the use of `/run' if desired, for example. (If you are using
3095 Autoconf 2.70 or later, write it as `@runstatedir@'.)
3097 These variables specify the directory for installing certain specific
3098 types of files, if your program has them. Every GNU package should
3099 have Info files, so every program needs `infodir', but not all need
3100 `libdir' or `lispdir'.
3103 The directory for installing header files to be included by user
3104 programs with the C `#include' preprocessor directive. This
3105 should normally be `/usr/local/include', but write it as
3106 `$(prefix)/include'. (If you are using Autoconf, write it as
3109 Most compilers other than GCC do not look for header files in
3110 directory `/usr/local/include'. So installing the header files
3111 this way is only useful with GCC. Sometimes this is not a problem
3112 because some libraries are only really intended to work with GCC.
3113 But some libraries are intended to work with other compilers.
3114 They should install their header files in two places, one
3115 specified by `includedir' and one specified by `oldincludedir'.
3118 The directory for installing `#include' header files for use with
3119 compilers other than GCC. This should normally be `/usr/include'.
3120 (If you are using Autoconf, you can write it as `@oldincludedir@'.)
3122 The Makefile commands should check whether the value of
3123 `oldincludedir' is empty. If it is, they should not try to use
3124 it; they should cancel the second installation of the header files.
3126 A package should not replace an existing header in this directory
3127 unless the header came from the same package. Thus, if your Foo
3128 package provides a header file `foo.h', then it should install the
3129 header file in the `oldincludedir' directory if either (1) there
3130 is no `foo.h' there or (2) the `foo.h' that exists came from the
3133 To tell whether `foo.h' came from the Foo package, put a magic
3134 string in the file--part of a comment--and `grep' for that string.
3137 The directory for installing documentation files (other than Info)
3138 for this package. By default, it should be
3139 `/usr/local/share/doc/YOURPKG', but it should be written as
3140 `$(datarootdir)/doc/YOURPKG'. (If you are using Autoconf, write
3141 it as `@docdir@'.) The YOURPKG subdirectory, which may include a
3142 version number, prevents collisions among files with common names,
3146 The directory for installing the Info files for this package. By
3147 default, it should be `/usr/local/share/info', but it should be
3148 written as `$(datarootdir)/info'. (If you are using Autoconf,
3149 write it as `@infodir@'.) `infodir' is separate from `docdir' for
3150 compatibility with existing practice.
3156 Directories for installing documentation files in the particular
3157 format. They should all be set to `$(docdir)' by default. (If
3158 you are using Autoconf, write them as `@htmldir@', `@dvidir@',
3159 etc.) Packages which supply several translations of their
3160 documentation should install them in `$(htmldir)/'LL,
3161 `$(pdfdir)/'LL, etc. where LL is a locale abbreviation such as
3165 The directory for object files and libraries of object code. Do
3166 not install executables here, they probably ought to go in
3167 `$(libexecdir)' instead. The value of `libdir' should normally be
3168 `/usr/local/lib', but write it as `$(exec_prefix)/lib'. (If you
3169 are using Autoconf, write it as `@libdir@'.)
3172 The directory for installing any Emacs Lisp files in this package.
3173 By default, it should be `/usr/local/share/emacs/site-lisp', but it
3174 should be written as `$(datarootdir)/emacs/site-lisp'.
3176 If you are using Autoconf, write the default as `@lispdir@'. In
3177 order to make `@lispdir@' work, you need the following lines in
3178 your `configure.ac' file:
3180 lispdir='${datarootdir}/emacs/site-lisp'
3184 The directory for installing locale-specific message catalogs for
3185 this package. By default, it should be `/usr/local/share/locale',
3186 but it should be written as `$(datarootdir)/locale'. (If you are
3187 using Autoconf, write it as `@localedir@'.) This directory
3188 usually has a subdirectory per locale.
3190 Unix-style man pages are installed in one of the following:
3193 The top-level directory for installing the man pages (if any) for
3194 this package. It will normally be `/usr/local/share/man', but you
3195 should write it as `$(datarootdir)/man'. (If you are using
3196 Autoconf, write it as `@mandir@'.)
3199 The directory for installing section 1 man pages. Write it as
3203 The directory for installing section 2 man pages. Write it as
3207 *Don't make the primary documentation for any GNU software be a
3208 man page. Write a manual in Texinfo instead. Man pages are just
3209 for the sake of people running GNU software on Unix, which is a
3210 secondary application only.*
3213 The file name extension for the installed man page. This should
3214 contain a period followed by the appropriate digit; it should
3218 The file name extension for installed section 1 man pages.
3221 The file name extension for installed section 2 man pages.
3224 Use these names instead of `manext' if the package needs to
3225 install man pages in more than one section of the manual.
3227 And finally, you should set the following variable:
3230 The directory for the sources being compiled. The value of this
3231 variable is normally inserted by the `configure' shell script.
3232 (If you are using Autoconf, use `srcdir = @srcdir@'.)
3236 # Common prefix for installation directories.
3237 # NOTE: This directory must exist when you start the install.
3239 datarootdir = $(prefix)/share
3240 datadir = $(datarootdir)
3241 exec_prefix = $(prefix)
3242 # Where to put the executable for the command `gcc'.
3243 bindir = $(exec_prefix)/bin
3244 # Where to put the directories used by the compiler.
3245 libexecdir = $(exec_prefix)/libexec
3246 # Where to put the Info files.
3247 infodir = $(datarootdir)/info
3249 If your program installs a large number of files into one of the
3250 standard user-specified directories, it might be useful to group them
3251 into a subdirectory particular to that program. If you do this, you
3252 should write the `install' rule to create these subdirectories.
3254 Do not expect the user to include the subdirectory name in the value
3255 of any of the variables listed above. The idea of having a uniform set
3256 of variable names for installation directories is to enable the user to
3257 specify the exact same values for several different GNU packages. In
3258 order for this to be useful, all the packages must be designed so that
3259 they will work sensibly when the user does so.
3261 At times, not all of these variables may be implemented in the
3262 current release of Autoconf and/or Automake; but as of Autoconf 2.60, we
3263 believe all of them are. When any are missing, the descriptions here
3264 serve as specifications for what Autoconf will implement. As a
3265 programmer, you can either use a development version of Autoconf or
3266 avoid using these variables until a stable release is made which
3270 File: make.info, Node: Standard Targets, Next: Install Command Categories, Prev: Directory Variables, Up: Makefile Conventions
3272 15.6 Standard Targets for Users
3273 ===============================
3275 All GNU programs should have the following targets in their Makefiles:
3278 Compile the entire program. This should be the default target.
3279 This target need not rebuild any documentation files; Info files
3280 should normally be included in the distribution, and DVI (and other
3281 documentation format) files should be made only when explicitly
3284 By default, the Make rules should compile and link with `-g', so
3285 that executable programs have debugging symbols. Otherwise, you
3286 are essentially helpless in the face of a crash, and it is often
3287 far from easy to reproduce with a fresh build.
3290 Compile the program and copy the executables, libraries, and so on
3291 to the file names where they should reside for actual use. If
3292 there is a simple test to verify that a program is properly
3293 installed, this target should run that test.
3295 Do not strip executables when installing them. This helps eventual
3296 debugging that may be needed later, and nowadays disk space is
3297 cheap and dynamic loaders typically ensure debug sections are not
3298 loaded during normal execution. Users that need stripped binaries
3299 may invoke the `install-strip' target to do that.
3301 If possible, write the `install' target rule so that it does not
3302 modify anything in the directory where the program was built,
3303 provided `make all' has just been done. This is convenient for
3304 building the program under one user name and installing it under
3307 The commands should create all the directories in which files are
3308 to be installed, if they don't already exist. This includes the
3309 directories specified as the values of the variables `prefix' and
3310 `exec_prefix', as well as all subdirectories that are needed. One
3311 way to do this is by means of an `installdirs' target as described
3314 Use `-' before any command for installing a man page, so that
3315 `make' will ignore any errors. This is in case there are systems
3316 that don't have the Unix man page documentation system installed.
3318 The way to install Info files is to copy them into `$(infodir)'
3319 with `$(INSTALL_DATA)' (*note Command Variables::), and then run
3320 the `install-info' program if it is present. `install-info' is a
3321 program that edits the Info `dir' file to add or update the menu
3322 entry for the given Info file; it is part of the Texinfo package.
3324 Here is a sample rule to install an Info file that also tries to
3325 handle some additional situations, such as `install-info' not
3328 do-install-info: foo.info installdirs
3330 # Prefer an info file in . to one in srcdir.
3331 if test -f foo.info; then d=.; \
3332 else d="$(srcdir)"; fi; \
3333 $(INSTALL_DATA) $$d/foo.info \
3334 "$(DESTDIR)$(infodir)/foo.info"
3335 # Run install-info only if it exists.
3336 # Use `if' instead of just prepending `-' to the
3337 # line so we notice real errors from install-info.
3338 # Use `$(SHELL) -c' because some shells do not
3339 # fail gracefully when there is an unknown command.
3341 if $(SHELL) -c 'install-info --version' \
3342 >/dev/null 2>&1; then \
3343 install-info --dir-file="$(DESTDIR)$(infodir)/dir" \
3344 "$(DESTDIR)$(infodir)/foo.info"; \
3347 When writing the `install' target, you must classify all the
3348 commands into three categories: normal ones, "pre-installation"
3349 commands and "post-installation" commands. *Note Install Command
3356 These targets install documentation in formats other than Info;
3357 they're intended to be called explicitly by the person installing
3358 the package, if that format is desired. GNU prefers Info files,
3359 so these must be installed by the `install' target.
3361 When you have many documentation files to install, we recommend
3362 that you avoid collisions and clutter by arranging for these
3363 targets to install in subdirectories of the appropriate
3364 installation directory, such as `htmldir'. As one example, if
3365 your package has multiple manuals, and you wish to install HTML
3366 documentation with many files (such as the "split" mode output by
3367 `makeinfo --html'), you'll certainly want to use subdirectories,
3368 or two nodes with the same name in different manuals will
3369 overwrite each other.
3371 Please make these `install-FORMAT' targets invoke the commands for
3372 the FORMAT target, for example, by making FORMAT a dependency.
3375 Delete all the installed files--the copies that the `install' and
3376 `install-*' targets create.
3378 This rule should not modify the directories where compilation is
3379 done, only the directories where files are installed.
3381 The uninstallation commands are divided into three categories,
3382 just like the installation commands. *Note Install Command
3386 Like `install', but strip the executable files while installing
3387 them. In simple cases, this target can use the `install' target in
3391 $(MAKE) INSTALL_PROGRAM='$(INSTALL_PROGRAM) -s' \
3394 But if the package installs scripts as well as real executables,
3395 the `install-strip' target can't just refer to the `install'
3396 target; it has to strip the executables but not the scripts.
3398 `install-strip' should not strip the executables in the build
3399 directory which are being copied for installation. It should only
3400 strip the copies that are installed.
3402 Normally we do not recommend stripping an executable unless you
3403 are sure the program has no bugs. However, it can be reasonable
3404 to install a stripped executable for actual execution while saving
3405 the unstripped executable elsewhere in case there is a bug.
3408 Delete all files in the current directory that are normally
3409 created by building the program. Also delete files in other
3410 directories if they are created by this makefile. However, don't
3411 delete the files that record the configuration. Also preserve
3412 files that could be made by building, but normally aren't because
3413 the distribution comes with them. There is no need to delete
3414 parent directories that were created with `mkdir -p', since they
3415 could have existed anyway.
3417 Delete `.dvi' files here if they are not part of the distribution.
3420 Delete all files in the current directory (or created by this
3421 makefile) that are created by configuring or building the program.
3422 If you have unpacked the source and built the program without
3423 creating any other files, `make distclean' should leave only the
3424 files that were in the distribution. However, there is no need to
3425 delete parent directories that were created with `mkdir -p', since
3426 they could have existed anyway.
3429 Like `clean', but may refrain from deleting a few files that people
3430 normally don't want to recompile. For example, the `mostlyclean'
3431 target for GCC does not delete `libgcc.a', because recompiling it
3432 is rarely necessary and takes a lot of time.
3435 Delete almost everything that can be reconstructed with this
3436 Makefile. This typically includes everything deleted by
3437 `distclean', plus more: C source files produced by Bison, tags
3438 tables, Info files, and so on.
3440 The reason we say "almost everything" is that running the command
3441 `make maintainer-clean' should not delete `configure' even if
3442 `configure' can be remade using a rule in the Makefile. More
3443 generally, `make maintainer-clean' should not delete anything that
3444 needs to exist in order to run `configure' and then begin to build
3445 the program. Also, there is no need to delete parent directories
3446 that were created with `mkdir -p', since they could have existed
3447 anyway. These are the only exceptions; `maintainer-clean' should
3448 delete everything else that can be rebuilt.
3450 The `maintainer-clean' target is intended to be used by a
3451 maintainer of the package, not by ordinary users. You may need
3452 special tools to reconstruct some of the files that `make
3453 maintainer-clean' deletes. Since these files are normally
3454 included in the distribution, we don't take care to make them easy
3455 to reconstruct. If you find you need to unpack the full
3456 distribution again, don't blame us.
3458 To help make users aware of this, the commands for the special
3459 `maintainer-clean' target should start with these two:
3461 @echo 'This command is intended for maintainers to use; it'
3462 @echo 'deletes files that may need special tools to rebuild.'
3465 Update a tags table for this program.
3468 Generate any Info files needed. The best way to write the rules
3473 foo.info: foo.texi chap1.texi chap2.texi
3474 $(MAKEINFO) $(srcdir)/foo.texi
3476 You must define the variable `MAKEINFO' in the Makefile. It should
3477 run the `makeinfo' program, which is part of the Texinfo
3480 Normally a GNU distribution comes with Info files, and that means
3481 the Info files are present in the source directory. Therefore,
3482 the Make rule for an info file should update it in the source
3483 directory. When users build the package, ordinarily Make will not
3484 update the Info files because they will already be up to date.
3490 Generate documentation files in the given format. These targets
3491 should always exist, but any or all can be a no-op if the given
3492 output format cannot be generated. These targets should not be
3493 dependencies of the `all' target; the user must manually invoke
3496 Here's an example rule for generating DVI files from Texinfo:
3500 foo.dvi: foo.texi chap1.texi chap2.texi
3501 $(TEXI2DVI) $(srcdir)/foo.texi
3503 You must define the variable `TEXI2DVI' in the Makefile. It
3504 should run the program `texi2dvi', which is part of the Texinfo
3505 distribution. (`texi2dvi' uses TeX to do the real work of
3506 formatting. TeX is not distributed with Texinfo.) Alternatively,
3507 write only the dependencies, and allow GNU `make' to provide the
3510 Here's another example, this one for generating HTML from Texinfo:
3514 foo.html: foo.texi chap1.texi chap2.texi
3515 $(TEXI2HTML) $(srcdir)/foo.texi
3517 Again, you would define the variable `TEXI2HTML' in the Makefile;
3518 for example, it might run `makeinfo --no-split --html' (`makeinfo'
3519 is part of the Texinfo distribution).
3522 Create a distribution tar file for this program. The tar file
3523 should be set up so that the file names in the tar file start with
3524 a subdirectory name which is the name of the package it is a
3525 distribution for. This name can include the version number.
3527 For example, the distribution tar file of GCC version 1.40 unpacks
3528 into a subdirectory named `gcc-1.40'.
3530 The easiest way to do this is to create a subdirectory
3531 appropriately named, use `ln' or `cp' to install the proper files
3532 in it, and then `tar' that subdirectory.
3534 Compress the tar file with `gzip'. For example, the actual
3535 distribution file for GCC version 1.40 is called `gcc-1.40.tar.gz'.
3536 It is ok to support other free compression formats as well.
3538 The `dist' target should explicitly depend on all non-source files
3539 that are in the distribution, to make sure they are up to date in
3540 the distribution. *Note Making Releases: (standards)Releases.
3543 Perform self-tests (if any). The user must build the program
3544 before running the tests, but need not install the program; you
3545 should write the self-tests so that they work when the program is
3546 built but not installed.
3548 The following targets are suggested as conventional names, for
3549 programs in which they are useful.
3552 Perform installation tests (if any). The user must build and
3553 install the program before running the tests. You should not
3554 assume that `$(bindir)' is in the search path.
3557 It's useful to add a target named `installdirs' to create the
3558 directories where files are installed, and their parent
3559 directories. There is a script called `mkinstalldirs' which is
3560 convenient for this; you can find it in the Gnulib package. You
3561 can use a rule like this:
3563 # Make sure all installation directories (e.g. $(bindir))
3564 # actually exist by making them if necessary.
3565 installdirs: mkinstalldirs
3566 $(srcdir)/mkinstalldirs $(bindir) $(datadir) \
3567 $(libdir) $(infodir) \
3570 or, if you wish to support `DESTDIR' (strongly encouraged),
3572 # Make sure all installation directories (e.g. $(bindir))
3573 # actually exist by making them if necessary.
3574 installdirs: mkinstalldirs
3575 $(srcdir)/mkinstalldirs \
3576 $(DESTDIR)$(bindir) $(DESTDIR)$(datadir) \
3577 $(DESTDIR)$(libdir) $(DESTDIR)$(infodir) \
3580 This rule should not modify the directories where compilation is
3581 done. It should do nothing but create installation directories.
3584 File: make.info, Node: Install Command Categories, Prev: Standard Targets, Up: Makefile Conventions
3586 15.7 Install Command Categories
3587 ===============================
3589 When writing the `install' target, you must classify all the commands
3590 into three categories: normal ones, "pre-installation" commands and
3591 "post-installation" commands.
3593 Normal commands move files into their proper places, and set their
3594 modes. They may not alter any files except the ones that come entirely
3595 from the package they belong to.
3597 Pre-installation and post-installation commands may alter other
3598 files; in particular, they can edit global configuration files or data
3601 Pre-installation commands are typically executed before the normal
3602 commands, and post-installation commands are typically run after the
3605 The most common use for a post-installation command is to run
3606 `install-info'. This cannot be done with a normal command, since it
3607 alters a file (the Info directory) which does not come entirely and
3608 solely from the package being installed. It is a post-installation
3609 command because it needs to be done after the normal command which
3610 installs the package's Info files.
3612 Most programs don't need any pre-installation commands, but we have
3613 the feature just in case it is needed.
3615 To classify the commands in the `install' rule into these three
3616 categories, insert "category lines" among them. A category line
3617 specifies the category for the commands that follow.
3619 A category line consists of a tab and a reference to a special Make
3620 variable, plus an optional comment at the end. There are three
3621 variables you can use, one for each category; the variable name
3622 specifies the category. Category lines are no-ops in ordinary execution
3623 because these three Make variables are normally undefined (and you
3624 _should not_ define them in the makefile).
3626 Here are the three possible category lines, each with a comment that
3627 explains what it means:
3629 $(PRE_INSTALL) # Pre-install commands follow.
3630 $(POST_INSTALL) # Post-install commands follow.
3631 $(NORMAL_INSTALL) # Normal commands follow.
3633 If you don't use a category line at the beginning of the `install'
3634 rule, all the commands are classified as normal until the first category
3635 line. If you don't use any category lines, all the commands are
3636 classified as normal.
3638 These are the category lines for `uninstall':
3640 $(PRE_UNINSTALL) # Pre-uninstall commands follow.
3641 $(POST_UNINSTALL) # Post-uninstall commands follow.
3642 $(NORMAL_UNINSTALL) # Normal commands follow.
3644 Typically, a pre-uninstall command would be used for deleting entries
3645 from the Info directory.
3647 If the `install' or `uninstall' target has any dependencies which
3648 act as subroutines of installation, then you should start _each_
3649 dependency's commands with a category line, and start the main target's
3650 commands with a category line also. This way, you can ensure that each
3651 command is placed in the right category regardless of which of the
3652 dependencies actually run.
3654 Pre-installation and post-installation commands should not run any
3655 programs except for these:
3657 [ basename bash cat chgrp chmod chown cmp cp dd diff echo
3658 egrep expand expr false fgrep find getopt grep gunzip gzip
3659 hostname install install-info kill ldconfig ln ls md5sum
3660 mkdir mkfifo mknod mv printenv pwd rm rmdir sed sort tee
3661 test touch true uname xargs yes
3663 The reason for distinguishing the commands in this way is for the
3664 sake of making binary packages. Typically a binary package contains
3665 all the executables and other files that need to be installed, and has
3666 its own method of installing them--so it does not need to run the normal
3667 installation commands. But installing the binary package does need to
3668 execute the pre-installation and post-installation commands.
3670 Programs to build binary packages work by extracting the
3671 pre-installation and post-installation commands. Here is one way of
3672 extracting the pre-installation commands (the `-s' option to `make' is
3673 needed to silence messages about entering subdirectories):
3675 make -s -n install -o all \
3676 PRE_INSTALL=pre-install \
3677 POST_INSTALL=post-install \
3678 NORMAL_INSTALL=normal-install \
3679 | gawk -f pre-install.awk
3681 where the file `pre-install.awk' could contain this:
3683 $0 ~ /^(normal-install|post-install)[ \t]*$/ {on = 0}
3685 $0 ~ /^pre-install[ \t]*$/ {on = 1}
3688 File: make.info, Node: Quick Reference, Next: Error Messages, Prev: Makefile Conventions, Up: Top
3690 Appendix A Quick Reference
3691 **************************
3693 This appendix summarizes the directives, text manipulation functions,
3694 and special variables which GNU `make' understands. *Note Special
3695 Targets::, *note Catalogue of Implicit Rules: Catalogue of Rules, and
3696 *note Summary of Options: Options Summary, for other summaries.
3698 Here is a summary of the directives GNU `make' recognizes:
3702 `define VARIABLE :='
3703 `define VARIABLE ::='
3704 `define VARIABLE +='
3705 `define VARIABLE ?='
3707 Define multi-line variables.
3711 Undefining variables.
3712 *Note Undefine Directive::.
3724 Conditionally evaluate part of the makefile.
3725 *Note Conditionals::.
3730 Include another makefile.
3731 *Note Including Other Makefiles: Include.
3733 `override VARIABLE-ASSIGNMENT'
3734 Define a variable, overriding any previous definition, even one
3735 from the command line.
3736 *Note The `override' Directive: Override Directive.
3739 Tell `make' to export all variables to child processes by default.
3740 *Note Communicating Variables to a Sub-`make': Variables/Recursion.
3743 `export VARIABLE-ASSIGNMENT'
3745 Tell `make' whether or not to export a particular variable to child
3747 *Note Communicating Variables to a Sub-`make': Variables/Recursion.
3749 `private VARIABLE-ASSIGNMENT'
3750 Do not allow this variable assignment to be inherited by
3752 *Note Suppressing Inheritance::.
3754 `vpath PATTERN PATH'
3755 Specify a search path for files matching a `%' pattern.
3756 *Note The `vpath' Directive: Selective Search.
3759 Remove all search paths previously specified for PATTERN.
3762 Remove all search paths previously specified in any `vpath'
3765 Here is a summary of the built-in functions (*note Functions::):
3767 `$(subst FROM,TO,TEXT)'
3768 Replace FROM with TO in TEXT.
3769 *Note Functions for String Substitution and Analysis: Text
3772 `$(patsubst PATTERN,REPLACEMENT,TEXT)'
3773 Replace words matching PATTERN with REPLACEMENT in TEXT.
3774 *Note Functions for String Substitution and Analysis: Text
3778 Remove excess whitespace characters from STRING.
3779 *Note Functions for String Substitution and Analysis: Text
3782 `$(findstring FIND,TEXT)'
3783 Locate FIND in TEXT.
3784 *Note Functions for String Substitution and Analysis: Text
3787 `$(filter PATTERN...,TEXT)'
3788 Select words in TEXT that match one of the PATTERN words.
3789 *Note Functions for String Substitution and Analysis: Text
3792 `$(filter-out PATTERN...,TEXT)'
3793 Select words in TEXT that _do not_ match any of the PATTERN words.
3794 *Note Functions for String Substitution and Analysis: Text
3798 Sort the words in LIST lexicographically, removing duplicates.
3799 *Note Functions for String Substitution and Analysis: Text
3803 Extract the Nth word (one-origin) of TEXT.
3804 *Note Functions for String Substitution and Analysis: Text
3808 Count the number of words in TEXT.
3809 *Note Functions for String Substitution and Analysis: Text
3812 `$(wordlist S,E,TEXT)'
3813 Returns the list of words in TEXT from S to E.
3814 *Note Functions for String Substitution and Analysis: Text
3817 `$(firstword NAMES...)'
3818 Extract the first word of NAMES.
3819 *Note Functions for String Substitution and Analysis: Text
3822 `$(lastword NAMES...)'
3823 Extract the last word of NAMES.
3824 *Note Functions for String Substitution and Analysis: Text
3828 Extract the directory part of each file name.
3829 *Note Functions for File Names: File Name Functions.
3831 `$(notdir NAMES...)'
3832 Extract the non-directory part of each file name.
3833 *Note Functions for File Names: File Name Functions.
3835 `$(suffix NAMES...)'
3836 Extract the suffix (the last `.' and following characters) of each
3838 *Note Functions for File Names: File Name Functions.
3840 `$(basename NAMES...)'
3841 Extract the base name (name without suffix) of each file name.
3842 *Note Functions for File Names: File Name Functions.
3844 `$(addsuffix SUFFIX,NAMES...)'
3845 Append SUFFIX to each word in NAMES.
3846 *Note Functions for File Names: File Name Functions.
3848 `$(addprefix PREFIX,NAMES...)'
3849 Prepend PREFIX to each word in NAMES.
3850 *Note Functions for File Names: File Name Functions.
3852 `$(join LIST1,LIST2)'
3853 Join two parallel lists of words.
3854 *Note Functions for File Names: File Name Functions.
3856 `$(wildcard PATTERN...)'
3857 Find file names matching a shell file name pattern (_not_ a `%'
3859 *Note The Function `wildcard': Wildcard Function.
3861 `$(realpath NAMES...)'
3862 For each file name in NAMES, expand to an absolute name that does
3863 not contain any `.', `..', nor symlinks.
3864 *Note Functions for File Names: File Name Functions.
3866 `$(abspath NAMES...)'
3867 For each file name in NAMES, expand to an absolute name that does
3868 not contain any `.' or `..' components, but preserves symlinks.
3869 *Note Functions for File Names: File Name Functions.
3872 When this function is evaluated, `make' generates a fatal error
3873 with the message TEXT.
3874 *Note Functions That Control Make: Make Control Functions.
3876 `$(warning TEXT...)'
3877 When this function is evaluated, `make' generates a warning with
3879 *Note Functions That Control Make: Make Control Functions.
3882 Execute a shell command and return its output.
3883 *Note The `shell' Function: Shell Function.
3885 `$(origin VARIABLE)'
3886 Return a string describing how the `make' variable VARIABLE was
3888 *Note The `origin' Function: Origin Function.
3890 `$(flavor VARIABLE)'
3891 Return a string describing the flavor of the `make' variable
3893 *Note The `flavor' Function: Flavor Function.
3895 `$(foreach VAR,WORDS,TEXT)'
3896 Evaluate TEXT with VAR bound to each word in WORDS, and
3897 concatenate the results.
3898 *Note The `foreach' Function: Foreach Function.
3900 `$(if CONDITION,THEN-PART[,ELSE-PART])'
3901 Evaluate the condition CONDITION; if it's non-empty substitute the
3902 expansion of the THEN-PART otherwise substitute the expansion of
3904 *Note Functions for Conditionals: Conditional Functions.
3906 `$(or CONDITION1[,CONDITION2[,CONDITION3...]])'
3907 Evaluate each condition CONDITIONN one at a time; substitute the
3908 first non-empty expansion. If all expansions are empty, substitute
3910 *Note Functions for Conditionals: Conditional Functions.
3912 `$(and CONDITION1[,CONDITION2[,CONDITION3...]])'
3913 Evaluate each condition CONDITIONN one at a time; if any expansion
3914 results in the empty string substitute the empty string. If all
3915 expansions result in a non-empty string, substitute the expansion
3916 of the last CONDITION.
3917 *Note Functions for Conditionals: Conditional Functions.
3919 `$(call VAR,PARAM,...)'
3920 Evaluate the variable VAR replacing any references to `$(1)',
3921 `$(2)' with the first, second, etc. PARAM values.
3922 *Note The `call' Function: Call Function.
3925 Evaluate TEXT then read the results as makefile commands. Expands
3926 to the empty string.
3927 *Note The `eval' Function: Eval Function.
3929 `$(file OP FILENAME,TEXT)'
3930 Expand the arguments, then open the file FILENAME using mode OP
3931 and write TEXT to that file.
3932 *Note The `file' Function: File Function.
3935 Evaluates to the contents of the variable VAR, with no expansion
3937 *Note The `value' Function: Value Function.
3939 Here is a summary of the automatic variables. *Note Automatic
3940 Variables::, for full information.
3943 The file name of the target.
3946 The target member name, when the target is an archive member.
3949 The name of the first prerequisite.
3952 The names of all the prerequisites that are newer than the target,
3953 with spaces between them. For prerequisites which are archive
3954 members, only the named member is used (*note Archives::).
3958 The names of all the prerequisites, with spaces between them. For
3959 prerequisites which are archive members, only the named member is
3960 used (*note Archives::). The value of `$^' omits duplicate
3961 prerequisites, while `$+' retains them and preserves their order.
3964 The stem with which an implicit rule matches (*note How Patterns
3965 Match: Pattern Match.).
3969 The directory part and the file-within-directory part of `$@'.
3973 The directory part and the file-within-directory part of `$*'.
3977 The directory part and the file-within-directory part of `$%'.
3981 The directory part and the file-within-directory part of `$<'.
3985 The directory part and the file-within-directory part of `$^'.
3989 The directory part and the file-within-directory part of `$+'.
3993 The directory part and the file-within-directory part of `$?'.
3995 These variables are used specially by GNU `make':
3998 Makefiles to be read on every invocation of `make'.
3999 *Note The Variable `MAKEFILES': MAKEFILES Variable.
4002 Directory search path for files not found in the current directory.
4003 *Note `VPATH' Search Path for All Prerequisites: General Search.
4006 The name of the system default command interpreter, usually
4007 `/bin/sh'. You can set `SHELL' in the makefile to change the
4008 shell used to run recipes. *Note Recipe Execution: Execution.
4009 The `SHELL' variable is handled specially when importing from and
4010 exporting to the environment. *Note Choosing the Shell::.
4013 On MS-DOS only, the name of the command interpreter that is to be
4014 used by `make'. This value takes precedence over the value of
4015 `SHELL'. *Note MAKESHELL variable: Execution.
4018 The name with which `make' was invoked. Using this variable in
4019 recipes has special meaning. *Note How the `MAKE' Variable Works:
4023 The built-in variable `MAKE_VERSION' expands to the version number
4024 of the GNU `make' program.
4027 The built-in variable `MAKE_HOST' expands to a string representing
4028 the host that GNU `make' was built to run on.
4031 The number of levels of recursion (sub-`make's).
4032 *Note Variables/Recursion::.
4035 The flags given to `make'. You can set this in the environment or
4036 a makefile to set flags.
4037 *Note Communicating Options to a Sub-`make': Options/Recursion.
4039 It is _never_ appropriate to use `MAKEFLAGS' directly in a recipe
4040 line: its contents may not be quoted correctly for use in the
4041 shell. Always allow recursive `make''s to obtain these values
4042 through the environment from its parent.
4045 Other flags parsed by `make'. You can set this in the environment
4046 or a makefile to set `make' command-line flags. GNU `make' never
4047 sets this variable itself. This variable is only needed if you'd
4048 like to set GNU `make'-specific flags in a POSIX-compliant
4049 makefile. This variable will be seen by GNU `make' and ignored by
4050 other `make' implementations. It's not needed if you only use GNU
4051 `make'; just use `MAKEFLAGS' directly. *Note Communicating
4052 Options to a Sub-`make': Options/Recursion.
4055 The targets given to `make' on the command line. Setting this
4056 variable has no effect on the operation of `make'.
4057 *Note Arguments to Specify the Goals: Goals.
4060 Set to the pathname of the current working directory (after all
4061 `-C' options are processed, if any). Setting this variable has no
4062 effect on the operation of `make'.
4063 *Note Recursive Use of `make': Recursion.
4066 The default list of suffixes before `make' reads any makefiles.
4069 Defines the naming of the libraries `make' searches for, and their
4071 *Note Directory Search for Link Libraries: Libraries/Search.
4074 File: make.info, Node: Error Messages, Next: Complex Makefile, Prev: Quick Reference, Up: Top
4076 Appendix B Errors Generated by Make
4077 ***********************************
4079 Here is a list of the more common errors you might see generated by
4080 `make', and some information about what they mean and how to fix them.
4082 Sometimes `make' errors are not fatal, especially in the presence of
4083 a `-' prefix on a recipe line, or the `-k' command line option. Errors
4084 that are fatal are prefixed with the string `***'.
4086 Error messages are all either prefixed with the name of the program
4087 (usually `make'), or, if the error is found in a makefile, the name of
4088 the file and line number containing the problem.
4090 In the table below, these common prefixes are left off.
4093 `[FOO] SIGNAL DESCRIPTION'
4094 These errors are not really `make' errors at all. They mean that a
4095 program that `make' invoked as part of a recipe returned a non-0
4096 error code (`Error NN'), which `make' interprets as failure, or it
4097 exited in some other abnormal fashion (with a signal of some
4098 type). *Note Errors in Recipes: Errors.
4100 If no `***' is attached to the message, then the sub-process failed
4101 but the rule in the makefile was prefixed with the `-' special
4102 character, so `make' ignored the error.
4104 `missing separator. Stop.'
4105 `missing separator (did you mean TAB instead of 8 spaces?). Stop.'
4106 This means that `make' could not understand much of anything about
4107 the makefile line it just read. GNU `make' looks for various
4108 separators (`:', `=', recipe prefix characters, etc.) to indicate
4109 what kind of line it's parsing. This message means it couldn't
4112 One of the most common reasons for this message is that you (or
4113 perhaps your oh-so-helpful editor, as is the case with many
4114 MS-Windows editors) have attempted to indent your recipe lines
4115 with spaces instead of a tab character. In this case, `make' will
4116 use the second form of the error above. Remember that every line
4117 in the recipe must begin with a tab character (unless you set
4118 `.RECIPEPREFIX'; *note Special Variables::). Eight spaces do not
4119 count. *Note Rule Syntax::.
4121 `recipe commences before first target. Stop.'
4122 `missing rule before recipe. Stop.'
4123 This means the first thing in the makefile seems to be part of a
4124 recipe: it begins with a recipe prefix character and doesn't
4125 appear to be a legal `make' directive (such as a variable
4126 assignment). Recipes must always be associated with a target.
4128 The second form is generated if the line has a semicolon as the
4129 first non-whitespace character; `make' interprets this to mean you
4130 left out the "target: prerequisite" section of a rule. *Note Rule
4133 `No rule to make target `XXX'.'
4134 `No rule to make target `XXX', needed by `YYY'.'
4135 This means that `make' decided it needed to build a target, but
4136 then couldn't find any instructions in the makefile on how to do
4137 that, either explicit or implicit (including in the default rules
4140 If you want that file to be built, you will need to add a rule to
4141 your makefile describing how that target can be built. Other
4142 possible sources of this problem are typos in the makefile (if
4143 that file name is wrong) or a corrupted source tree (if that file
4144 is not supposed to be built, but rather only a prerequisite).
4146 `No targets specified and no makefile found. Stop.'
4148 The former means that you didn't provide any targets to be built
4149 on the command line, and `make' couldn't find any makefiles to
4150 read in. The latter means that some makefile was found, but it
4151 didn't contain any default goal and none was given on the command
4152 line. GNU `make' has nothing to do in these situations. *Note
4153 Arguments to Specify the Makefile: Makefile Arguments.
4155 `Makefile `XXX' was not found.'
4156 `Included makefile `XXX' was not found.'
4157 A makefile specified on the command line (first form) or included
4158 (second form) was not found.
4160 `warning: overriding recipe for target `XXX''
4161 `warning: ignoring old recipe for target `XXX''
4162 GNU `make' allows only one recipe to be specified per target
4163 (except for double-colon rules). If you give a recipe for a target
4164 which already has been defined to have one, this warning is issued
4165 and the second recipe will overwrite the first. *Note Multiple
4166 Rules for One Target: Multiple Rules.
4168 `Circular XXX <- YYY dependency dropped.'
4169 This means that `make' detected a loop in the dependency graph:
4170 after tracing the prerequisite YYY of target XXX, and its
4171 prerequisites, etc., one of them depended on XXX again.
4173 `Recursive variable `XXX' references itself (eventually). Stop.'
4174 This means you've defined a normal (recursive) `make' variable XXX
4175 that, when it's expanded, will refer to itself (XXX). This is not
4176 allowed; either use simply-expanded variables (`:=' or `::=') or
4177 use the append operator (`+='). *Note How to Use Variables: Using
4180 `Unterminated variable reference. Stop.'
4181 This means you forgot to provide the proper closing parenthesis or
4182 brace in your variable or function reference.
4184 `insufficient arguments to function `XXX'. Stop.'
4185 This means you haven't provided the requisite number of arguments
4186 for this function. See the documentation of the function for a
4187 description of its arguments. *Note Functions for Transforming
4190 `missing target pattern. Stop.'
4191 `multiple target patterns. Stop.'
4192 `target pattern contains no `%'. Stop.'
4193 `mixed implicit and static pattern rules. Stop.'
4194 These are generated for malformed static pattern rules. The first
4195 means there's no pattern in the target section of the rule; the
4196 second means there are multiple patterns in the target section;
4197 the third means the target doesn't contain a pattern character
4198 (`%'); and the fourth means that all three parts of the static
4199 pattern rule contain pattern characters (`%')-only the first two
4200 parts should. If you see these errors and you aren't trying to
4201 create a static pattern rule, check the value of any variables in
4202 your target and prerequisite lists to be sure they do not contain
4203 colons. *Note Syntax of Static Pattern Rules: Static Usage.
4205 `warning: -jN forced in submake: disabling jobserver mode.'
4206 This warning and the next are generated if `make' detects error
4207 conditions related to parallel processing on systems where
4208 sub-`make's can communicate (*note Communicating Options to a
4209 Sub-`make': Options/Recursion.). This warning is generated if a
4210 recursive invocation of a `make' process is forced to have `-jN'
4211 in its argument list (where N is greater than one). This could
4212 happen, for example, if you set the `MAKE' environment variable to
4213 `make -j2'. In this case, the sub-`make' doesn't communicate with
4214 other `make' processes and will simply pretend it has two jobs of
4217 `warning: jobserver unavailable: using -j1. Add `+' to parent make rule.'
4218 In order for `make' processes to communicate, the parent will pass
4219 information to the child. Since this could result in problems if
4220 the child process isn't actually a `make', the parent will only do
4221 this if it thinks the child is a `make'. The parent uses the
4222 normal algorithms to determine this (*note How the `MAKE' Variable
4223 Works: MAKE Variable.). If the makefile is constructed such that
4224 the parent doesn't know the child is a `make' process, then the
4225 child will receive only part of the information necessary. In
4226 this case, the child will generate this warning message and
4227 proceed with its build in a sequential manner.
4231 File: make.info, Node: Complex Makefile, Next: GNU Free Documentation License, Prev: Error Messages, Up: Top
4233 Appendix C Complex Makefile Example
4234 ***********************************
4236 Here is the makefile for the GNU `tar' program. This is a moderately
4237 complex makefile. The first line uses a `#!' setting to allow the
4238 makefile to be executed directly.
4240 Because it is the first target, the default goal is `all'. An
4241 interesting feature of this makefile is that `testpad.h' is a source
4242 file automatically created by the `testpad' program, itself compiled
4245 If you type `make' or `make all', then `make' creates the `tar'
4246 executable, the `rmt' daemon that provides remote tape access, and the
4247 `tar.info' Info file.
4249 If you type `make install', then `make' not only creates `tar',
4250 `rmt', and `tar.info', but also installs them.
4252 If you type `make clean', then `make' removes the `.o' files, and
4253 the `tar', `rmt', `testpad', `testpad.h', and `core' files.
4255 If you type `make distclean', then `make' not only removes the same
4256 files as does `make clean' but also the `TAGS', `Makefile', and
4257 `config.status' files. (Although it is not evident, this makefile (and
4258 `config.status') is generated by the user with the `configure' program,
4259 which is provided in the `tar' distribution, but is not shown here.)
4261 If you type `make realclean', then `make' removes the same files as
4262 does `make distclean' and also removes the Info files generated from
4265 In addition, there are targets `shar' and `dist' that create
4269 # Generated automatically from Makefile.in by configure.
4270 # Un*x Makefile for GNU tar program.
4271 # Copyright (C) 1991 Free Software Foundation, Inc.
4273 # This program is free software; you can redistribute
4274 # it and/or modify it under the terms of the GNU
4275 # General Public License ...
4281 #### Start of system configuration section. ####
4285 # If you use gcc, you should either run the
4286 # fixincludes script that comes with it or else use
4287 # gcc with the -traditional option. Otherwise ioctl
4288 # calls will be compiled incorrectly on some systems.
4291 INSTALL = /usr/local/bin/install -c
4292 INSTALLDATA = /usr/local/bin/install -c -m 644
4294 # Things you might add to DEFS:
4295 # -DSTDC_HEADERS If you have ANSI C headers and
4297 # -DPOSIX If you have POSIX.1 headers and
4299 # -DBSD42 If you have sys/dir.h (unless
4300 # you use -DPOSIX), sys/file.h,
4301 # and st_blocks in `struct stat'.
4302 # -DUSG If you have System V/ANSI C
4303 # string and memory functions
4304 # and headers, sys/sysmacros.h,
4305 # fcntl.h, getcwd, no valloc,
4306 # and ndir.h (unless
4307 # you use -DDIRENT).
4308 # -DNO_MEMORY_H If USG or STDC_HEADERS but do not
4310 # -DDIRENT If USG and you have dirent.h
4311 # instead of ndir.h.
4312 # -DSIGTYPE=int If your signal handlers
4313 # return int, not void.
4314 # -DNO_MTIO If you lack sys/mtio.h
4316 # -DNO_REMOTE If you do not have a remote shell
4318 # -DUSE_REXEC To use rexec for remote tape
4319 # operations instead of
4320 # forking rsh or remsh.
4321 # -DVPRINTF_MISSING If you lack vprintf function
4322 # (but have _doprnt).
4323 # -DDOPRNT_MISSING If you lack _doprnt function.
4324 # Also need to define
4325 # -DVPRINTF_MISSING.
4326 # -DFTIME_MISSING If you lack ftime system call.
4327 # -DSTRSTR_MISSING If you lack strstr function.
4328 # -DVALLOC_MISSING If you lack valloc function.
4329 # -DMKDIR_MISSING If you lack mkdir and
4330 # rmdir system calls.
4331 # -DRENAME_MISSING If you lack rename system call.
4332 # -DFTRUNCATE_MISSING If you lack ftruncate
4334 # -DV7 On Version 7 Unix (not
4335 # tested in a long time).
4336 # -DEMUL_OPEN3 If you lack a 3-argument version
4337 # of open, and want to emulate it
4338 # with system calls you do have.
4339 # -DNO_OPEN3 If you lack the 3-argument open
4340 # and want to disable the tar -k
4341 # option instead of emulating open.
4342 # -DXENIX If you have sys/inode.h
4343 # and need it 94 to be included.
4345 DEFS = -DSIGTYPE=int -DDIRENT -DSTRSTR_MISSING \
4346 -DVPRINTF_MISSING -DBSD42
4347 # Set this to rtapelib.o unless you defined NO_REMOTE,
4348 # in which case make it empty.
4349 RTAPELIB = rtapelib.o
4351 DEF_AR_FILE = /dev/rmt8
4355 CFLAGS = $(CDEBUG) -I. -I$(srcdir) $(DEFS) \
4356 -DDEF_AR_FILE=\"$(DEF_AR_FILE)\" \
4357 -DDEFBLOCKING=$(DEFBLOCKING)
4361 # Prefix for each installed program,
4362 # normally empty or `g'.
4365 # The directory to install tar in.
4366 bindir = $(prefix)/bin
4368 # The directory to install the info files in.
4369 infodir = $(prefix)/info
4371 #### End of system configuration section. ####
4373 SRCS_C = tar.c create.c extract.c buffer.c \
4374 getoldopt.c update.c gnu.c mangle.c \
4375 version.c list.c names.c diffarch.c \
4376 port.c wildmat.c getopt.c getopt1.c \
4379 SRCS = $(SRCS_C) $(SRCS_Y)
4380 OBJS = $(SRCS_C:.c=.o) $(SRCS_Y:.y=.o) $(RTAPELIB)
4381 AUX = README COPYING ChangeLog Makefile.in \
4382 makefile.pc configure configure.in \
4383 tar.texinfo tar.info* texinfo.tex \
4384 tar.h port.h open3.h getopt.h regex.h \
4385 rmt.h rmt.c rtapelib.c alloca.c \
4386 msd_dir.h msd_dir.c tcexparg.c \
4387 level-0 level-1 backup-specs testpad.c
4390 all: tar rmt tar.info
4393 $(CC) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)
4396 $(CC) $(CFLAGS) $(LDFLAGS) -o $@ rmt.c
4398 tar.info: tar.texinfo
4399 makeinfo tar.texinfo
4403 $(INSTALL) tar $(bindir)/$(binprefix)tar
4404 -test ! -f rmt || $(INSTALL) rmt /etc/rmt
4405 $(INSTALLDATA) $(srcdir)/tar.info* $(infodir)
4407 $(OBJS): tar.h port.h testpad.h
4408 regex.o buffer.o tar.o: regex.h
4409 # getdate.y has 8 shift/reduce conflicts.
4415 $(CC) -o $@ testpad.o
4422 rm -f *.o tar rmt testpad testpad.h core
4426 rm -f TAGS Makefile config.status
4429 realclean: distclean
4433 shar: $(SRCS) $(AUX)
4434 shar $(SRCS) $(AUX) | compress \
4435 > tar-`sed -e '/version_string/!d' \
4436 -e 's/[^0-9.]*\([0-9.]*\).*/\1/' \
4441 dist: $(SRCS) $(AUX)
4443 -e '/version_string/!d' \
4444 -e 's/[^0-9.]*\([0-9.]*\).*/\1/' \
4447 -rm -rf `cat .fname`
4449 ln $(SRCS) $(AUX) `cat .fname`
4450 tar chZf `cat .fname`.tar.Z `cat .fname`
4451 -rm -rf `cat .fname` .fname
4453 tar.zoo: $(SRCS) $(AUX)
4457 for X in $(SRCS) $(AUX) ; do \
4459 sed 's/$$/^M/' $$X \
4460 > tmp.dir/$$X ; done
4461 cd tmp.dir ; zoo aM ../tar.zoo *
4465 File: make.info, Node: GNU Free Documentation License, Next: Concept Index, Prev: Complex Makefile, Up: Top
4467 C.1 GNU Free Documentation License
4468 ==================================
4470 Version 1.3, 3 November 2008
4472 Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
4475 Everyone is permitted to copy and distribute verbatim copies
4476 of this license document, but changing it is not allowed.
4480 The purpose of this License is to make a manual, textbook, or other
4481 functional and useful document "free" in the sense of freedom: to
4482 assure everyone the effective freedom to copy and redistribute it,
4483 with or without modifying it, either commercially or
4484 noncommercially. Secondarily, this License preserves for the
4485 author and publisher a way to get credit for their work, while not
4486 being considered responsible for modifications made by others.
4488 This License is a kind of "copyleft", which means that derivative
4489 works of the document must themselves be free in the same sense.
4490 It complements the GNU General Public License, which is a copyleft
4491 license designed for free software.
4493 We have designed this License in order to use it for manuals for
4494 free software, because free software needs free documentation: a
4495 free program should come with manuals providing the same freedoms
4496 that the software does. But this License is not limited to
4497 software manuals; it can be used for any textual work, regardless
4498 of subject matter or whether it is published as a printed book.
4499 We recommend this License principally for works whose purpose is
4500 instruction or reference.
4502 1. APPLICABILITY AND DEFINITIONS
4504 This License applies to any manual or other work, in any medium,
4505 that contains a notice placed by the copyright holder saying it
4506 can be distributed under the terms of this License. Such a notice
4507 grants a world-wide, royalty-free license, unlimited in duration,
4508 to use that work under the conditions stated herein. The
4509 "Document", below, refers to any such manual or work. Any member
4510 of the public is a licensee, and is addressed as "you". You
4511 accept the license if you copy, modify or distribute the work in a
4512 way requiring permission under copyright law.
4514 A "Modified Version" of the Document means any work containing the
4515 Document or a portion of it, either copied verbatim, or with
4516 modifications and/or translated into another language.
4518 A "Secondary Section" is a named appendix or a front-matter section
4519 of the Document that deals exclusively with the relationship of the
4520 publishers or authors of the Document to the Document's overall
4521 subject (or to related matters) and contains nothing that could
4522 fall directly within that overall subject. (Thus, if the Document
4523 is in part a textbook of mathematics, a Secondary Section may not
4524 explain any mathematics.) The relationship could be a matter of
4525 historical connection with the subject or with related matters, or
4526 of legal, commercial, philosophical, ethical or political position
4529 The "Invariant Sections" are certain Secondary Sections whose
4530 titles are designated, as being those of Invariant Sections, in
4531 the notice that says that the Document is released under this
4532 License. If a section does not fit the above definition of
4533 Secondary then it is not allowed to be designated as Invariant.
4534 The Document may contain zero Invariant Sections. If the Document
4535 does not identify any Invariant Sections then there are none.
4537 The "Cover Texts" are certain short passages of text that are
4538 listed, as Front-Cover Texts or Back-Cover Texts, in the notice
4539 that says that the Document is released under this License. A
4540 Front-Cover Text may be at most 5 words, and a Back-Cover Text may
4541 be at most 25 words.
4543 A "Transparent" copy of the Document means a machine-readable copy,
4544 represented in a format whose specification is available to the
4545 general public, that is suitable for revising the document
4546 straightforwardly with generic text editors or (for images
4547 composed of pixels) generic paint programs or (for drawings) some
4548 widely available drawing editor, and that is suitable for input to
4549 text formatters or for automatic translation to a variety of
4550 formats suitable for input to text formatters. A copy made in an
4551 otherwise Transparent file format whose markup, or absence of
4552 markup, has been arranged to thwart or discourage subsequent
4553 modification by readers is not Transparent. An image format is
4554 not Transparent if used for any substantial amount of text. A
4555 copy that is not "Transparent" is called "Opaque".
4557 Examples of suitable formats for Transparent copies include plain
4558 ASCII without markup, Texinfo input format, LaTeX input format,
4559 SGML or XML using a publicly available DTD, and
4560 standard-conforming simple HTML, PostScript or PDF designed for
4561 human modification. Examples of transparent image formats include
4562 PNG, XCF and JPG. Opaque formats include proprietary formats that
4563 can be read and edited only by proprietary word processors, SGML or
4564 XML for which the DTD and/or processing tools are not generally
4565 available, and the machine-generated HTML, PostScript or PDF
4566 produced by some word processors for output purposes only.
4568 The "Title Page" means, for a printed book, the title page itself,
4569 plus such following pages as are needed to hold, legibly, the
4570 material this License requires to appear in the title page. For
4571 works in formats which do not have any title page as such, "Title
4572 Page" means the text near the most prominent appearance of the
4573 work's title, preceding the beginning of the body of the text.
4575 The "publisher" means any person or entity that distributes copies
4576 of the Document to the public.
4578 A section "Entitled XYZ" means a named subunit of the Document
4579 whose title either is precisely XYZ or contains XYZ in parentheses
4580 following text that translates XYZ in another language. (Here XYZ
4581 stands for a specific section name mentioned below, such as
4582 "Acknowledgements", "Dedications", "Endorsements", or "History".)
4583 To "Preserve the Title" of such a section when you modify the
4584 Document means that it remains a section "Entitled XYZ" according
4587 The Document may include Warranty Disclaimers next to the notice
4588 which states that this License applies to the Document. These
4589 Warranty Disclaimers are considered to be included by reference in
4590 this License, but only as regards disclaiming warranties: any other
4591 implication that these Warranty Disclaimers may have is void and
4592 has no effect on the meaning of this License.
4596 You may copy and distribute the Document in any medium, either
4597 commercially or noncommercially, provided that this License, the
4598 copyright notices, and the license notice saying this License
4599 applies to the Document are reproduced in all copies, and that you
4600 add no other conditions whatsoever to those of this License. You
4601 may not use technical measures to obstruct or control the reading
4602 or further copying of the copies you make or distribute. However,
4603 you may accept compensation in exchange for copies. If you
4604 distribute a large enough number of copies you must also follow
4605 the conditions in section 3.
4607 You may also lend copies, under the same conditions stated above,
4608 and you may publicly display copies.
4610 3. COPYING IN QUANTITY
4612 If you publish printed copies (or copies in media that commonly
4613 have printed covers) of the Document, numbering more than 100, and
4614 the Document's license notice requires Cover Texts, you must
4615 enclose the copies in covers that carry, clearly and legibly, all
4616 these Cover Texts: Front-Cover Texts on the front cover, and
4617 Back-Cover Texts on the back cover. Both covers must also clearly
4618 and legibly identify you as the publisher of these copies. The
4619 front cover must present the full title with all words of the
4620 title equally prominent and visible. You may add other material
4621 on the covers in addition. Copying with changes limited to the
4622 covers, as long as they preserve the title of the Document and
4623 satisfy these conditions, can be treated as verbatim copying in
4626 If the required texts for either cover are too voluminous to fit
4627 legibly, you should put the first ones listed (as many as fit
4628 reasonably) on the actual cover, and continue the rest onto
4631 If you publish or distribute Opaque copies of the Document
4632 numbering more than 100, you must either include a
4633 machine-readable Transparent copy along with each Opaque copy, or
4634 state in or with each Opaque copy a computer-network location from
4635 which the general network-using public has access to download
4636 using public-standard network protocols a complete Transparent
4637 copy of the Document, free of added material. If you use the
4638 latter option, you must take reasonably prudent steps, when you
4639 begin distribution of Opaque copies in quantity, to ensure that
4640 this Transparent copy will remain thus accessible at the stated
4641 location until at least one year after the last time you
4642 distribute an Opaque copy (directly or through your agents or
4643 retailers) of that edition to the public.
4645 It is requested, but not required, that you contact the authors of
4646 the Document well before redistributing any large number of
4647 copies, to give them a chance to provide you with an updated
4648 version of the Document.
4652 You may copy and distribute a Modified Version of the Document
4653 under the conditions of sections 2 and 3 above, provided that you
4654 release the Modified Version under precisely this License, with
4655 the Modified Version filling the role of the Document, thus
4656 licensing distribution and modification of the Modified Version to
4657 whoever possesses a copy of it. In addition, you must do these
4658 things in the Modified Version:
4660 A. Use in the Title Page (and on the covers, if any) a title
4661 distinct from that of the Document, and from those of
4662 previous versions (which should, if there were any, be listed
4663 in the History section of the Document). You may use the
4664 same title as a previous version if the original publisher of
4665 that version gives permission.
4667 B. List on the Title Page, as authors, one or more persons or
4668 entities responsible for authorship of the modifications in
4669 the Modified Version, together with at least five of the
4670 principal authors of the Document (all of its principal
4671 authors, if it has fewer than five), unless they release you
4672 from this requirement.
4674 C. State on the Title page the name of the publisher of the
4675 Modified Version, as the publisher.
4677 D. Preserve all the copyright notices of the Document.
4679 E. Add an appropriate copyright notice for your modifications
4680 adjacent to the other copyright notices.
4682 F. Include, immediately after the copyright notices, a license
4683 notice giving the public permission to use the Modified
4684 Version under the terms of this License, in the form shown in
4687 G. Preserve in that license notice the full lists of Invariant
4688 Sections and required Cover Texts given in the Document's
4691 H. Include an unaltered copy of this License.
4693 I. Preserve the section Entitled "History", Preserve its Title,
4694 and add to it an item stating at least the title, year, new
4695 authors, and publisher of the Modified Version as given on
4696 the Title Page. If there is no section Entitled "History" in
4697 the Document, create one stating the title, year, authors,
4698 and publisher of the Document as given on its Title Page,
4699 then add an item describing the Modified Version as stated in
4700 the previous sentence.
4702 J. Preserve the network location, if any, given in the Document
4703 for public access to a Transparent copy of the Document, and
4704 likewise the network locations given in the Document for
4705 previous versions it was based on. These may be placed in
4706 the "History" section. You may omit a network location for a
4707 work that was published at least four years before the
4708 Document itself, or if the original publisher of the version
4709 it refers to gives permission.
4711 K. For any section Entitled "Acknowledgements" or "Dedications",
4712 Preserve the Title of the section, and preserve in the
4713 section all the substance and tone of each of the contributor
4714 acknowledgements and/or dedications given therein.
4716 L. Preserve all the Invariant Sections of the Document,
4717 unaltered in their text and in their titles. Section numbers
4718 or the equivalent are not considered part of the section
4721 M. Delete any section Entitled "Endorsements". Such a section
4722 may not be included in the Modified Version.
4724 N. Do not retitle any existing section to be Entitled
4725 "Endorsements" or to conflict in title with any Invariant
4728 O. Preserve any Warranty Disclaimers.
4730 If the Modified Version includes new front-matter sections or
4731 appendices that qualify as Secondary Sections and contain no
4732 material copied from the Document, you may at your option
4733 designate some or all of these sections as invariant. To do this,
4734 add their titles to the list of Invariant Sections in the Modified
4735 Version's license notice. These titles must be distinct from any
4736 other section titles.
4738 You may add a section Entitled "Endorsements", provided it contains
4739 nothing but endorsements of your Modified Version by various
4740 parties--for example, statements of peer review or that the text
4741 has been approved by an organization as the authoritative
4742 definition of a standard.
4744 You may add a passage of up to five words as a Front-Cover Text,
4745 and a passage of up to 25 words as a Back-Cover Text, to the end
4746 of the list of Cover Texts in the Modified Version. Only one
4747 passage of Front-Cover Text and one of Back-Cover Text may be
4748 added by (or through arrangements made by) any one entity. If the
4749 Document already includes a cover text for the same cover,
4750 previously added by you or by arrangement made by the same entity
4751 you are acting on behalf of, you may not add another; but you may
4752 replace the old one, on explicit permission from the previous
4753 publisher that added the old one.
4755 The author(s) and publisher(s) of the Document do not by this
4756 License give permission to use their names for publicity for or to
4757 assert or imply endorsement of any Modified Version.
4759 5. COMBINING DOCUMENTS
4761 You may combine the Document with other documents released under
4762 this License, under the terms defined in section 4 above for
4763 modified versions, provided that you include in the combination
4764 all of the Invariant Sections of all of the original documents,
4765 unmodified, and list them all as Invariant Sections of your
4766 combined work in its license notice, and that you preserve all
4767 their Warranty Disclaimers.
4769 The combined work need only contain one copy of this License, and
4770 multiple identical Invariant Sections may be replaced with a single
4771 copy. If there are multiple Invariant Sections with the same name
4772 but different contents, make the title of each such section unique
4773 by adding at the end of it, in parentheses, the name of the
4774 original author or publisher of that section if known, or else a
4775 unique number. Make the same adjustment to the section titles in
4776 the list of Invariant Sections in the license notice of the
4779 In the combination, you must combine any sections Entitled
4780 "History" in the various original documents, forming one section
4781 Entitled "History"; likewise combine any sections Entitled
4782 "Acknowledgements", and any sections Entitled "Dedications". You
4783 must delete all sections Entitled "Endorsements."
4785 6. COLLECTIONS OF DOCUMENTS
4787 You may make a collection consisting of the Document and other
4788 documents released under this License, and replace the individual
4789 copies of this License in the various documents with a single copy
4790 that is included in the collection, provided that you follow the
4791 rules of this License for verbatim copying of each of the
4792 documents in all other respects.
4794 You may extract a single document from such a collection, and
4795 distribute it individually under this License, provided you insert
4796 a copy of this License into the extracted document, and follow
4797 this License in all other respects regarding verbatim copying of
4800 7. AGGREGATION WITH INDEPENDENT WORKS
4802 A compilation of the Document or its derivatives with other
4803 separate and independent documents or works, in or on a volume of
4804 a storage or distribution medium, is called an "aggregate" if the
4805 copyright resulting from the compilation is not used to limit the
4806 legal rights of the compilation's users beyond what the individual
4807 works permit. When the Document is included in an aggregate, this
4808 License does not apply to the other works in the aggregate which
4809 are not themselves derivative works of the Document.
4811 If the Cover Text requirement of section 3 is applicable to these
4812 copies of the Document, then if the Document is less than one half
4813 of the entire aggregate, the Document's Cover Texts may be placed
4814 on covers that bracket the Document within the aggregate, or the
4815 electronic equivalent of covers if the Document is in electronic
4816 form. Otherwise they must appear on printed covers that bracket
4817 the whole aggregate.
4821 Translation is considered a kind of modification, so you may
4822 distribute translations of the Document under the terms of section
4823 4. Replacing Invariant Sections with translations requires special
4824 permission from their copyright holders, but you may include
4825 translations of some or all Invariant Sections in addition to the
4826 original versions of these Invariant Sections. You may include a
4827 translation of this License, and all the license notices in the
4828 Document, and any Warranty Disclaimers, provided that you also
4829 include the original English version of this License and the
4830 original versions of those notices and disclaimers. In case of a
4831 disagreement between the translation and the original version of
4832 this License or a notice or disclaimer, the original version will
4835 If a section in the Document is Entitled "Acknowledgements",
4836 "Dedications", or "History", the requirement (section 4) to
4837 Preserve its Title (section 1) will typically require changing the
4842 You may not copy, modify, sublicense, or distribute the Document
4843 except as expressly provided under this License. Any attempt
4844 otherwise to copy, modify, sublicense, or distribute it is void,
4845 and will automatically terminate your rights under this License.
4847 However, if you cease all violation of this License, then your
4848 license from a particular copyright holder is reinstated (a)
4849 provisionally, unless and until the copyright holder explicitly
4850 and finally terminates your license, and (b) permanently, if the
4851 copyright holder fails to notify you of the violation by some
4852 reasonable means prior to 60 days after the cessation.
4854 Moreover, your license from a particular copyright holder is
4855 reinstated permanently if the copyright holder notifies you of the
4856 violation by some reasonable means, this is the first time you have
4857 received notice of violation of this License (for any work) from
4858 that copyright holder, and you cure the violation prior to 30 days
4859 after your receipt of the notice.
4861 Termination of your rights under this section does not terminate
4862 the licenses of parties who have received copies or rights from
4863 you under this License. If your rights have been terminated and
4864 not permanently reinstated, receipt of a copy of some or all of
4865 the same material does not give you any rights to use it.
4867 10. FUTURE REVISIONS OF THIS LICENSE
4869 The Free Software Foundation may publish new, revised versions of
4870 the GNU Free Documentation License from time to time. Such new
4871 versions will be similar in spirit to the present version, but may
4872 differ in detail to address new problems or concerns. See
4873 `http://www.gnu.org/copyleft/'.
4875 Each version of the License is given a distinguishing version
4876 number. If the Document specifies that a particular numbered
4877 version of this License "or any later version" applies to it, you
4878 have the option of following the terms and conditions either of
4879 that specified version or of any later version that has been
4880 published (not as a draft) by the Free Software Foundation. If
4881 the Document does not specify a version number of this License,
4882 you may choose any version ever published (not as a draft) by the
4883 Free Software Foundation. If the Document specifies that a proxy
4884 can decide which future versions of this License can be used, that
4885 proxy's public statement of acceptance of a version permanently
4886 authorizes you to choose that version for the Document.
4890 "Massive Multiauthor Collaboration Site" (or "MMC Site") means any
4891 World Wide Web server that publishes copyrightable works and also
4892 provides prominent facilities for anybody to edit those works. A
4893 public wiki that anybody can edit is an example of such a server.
4894 A "Massive Multiauthor Collaboration" (or "MMC") contained in the
4895 site means any set of copyrightable works thus published on the MMC
4898 "CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0
4899 license published by Creative Commons Corporation, a not-for-profit
4900 corporation with a principal place of business in San Francisco,
4901 California, as well as future copyleft versions of that license
4902 published by that same organization.
4904 "Incorporate" means to publish or republish a Document, in whole or
4905 in part, as part of another Document.
4907 An MMC is "eligible for relicensing" if it is licensed under this
4908 License, and if all works that were first published under this
4909 License somewhere other than this MMC, and subsequently
4910 incorporated in whole or in part into the MMC, (1) had no cover
4911 texts or invariant sections, and (2) were thus incorporated prior
4912 to November 1, 2008.
4914 The operator of an MMC Site may republish an MMC contained in the
4915 site under CC-BY-SA on the same site at any time before August 1,
4916 2009, provided the MMC is eligible for relicensing.
4919 ADDENDUM: How to use this License for your documents
4920 ====================================================
4922 To use this License in a document you have written, include a copy of
4923 the License in the document and put the following copyright and license
4924 notices just after the title page:
4926 Copyright (C) YEAR YOUR NAME.
4927 Permission is granted to copy, distribute and/or modify this document
4928 under the terms of the GNU Free Documentation License, Version 1.3
4929 or any later version published by the Free Software Foundation;
4930 with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
4931 Texts. A copy of the license is included in the section entitled ``GNU
4932 Free Documentation License''.
4934 If you have Invariant Sections, Front-Cover Texts and Back-Cover
4935 Texts, replace the "with...Texts." line with this:
4937 with the Invariant Sections being LIST THEIR TITLES, with
4938 the Front-Cover Texts being LIST, and with the Back-Cover Texts
4941 If you have Invariant Sections without Cover Texts, or some other
4942 combination of the three, merge those two alternatives to suit the
4945 If your document contains nontrivial examples of program code, we
4946 recommend releasing these examples in parallel under your choice of
4947 free software license, such as the GNU General Public License, to
4948 permit their use in free software.
4951 File: make.info, Node: Concept Index, Next: Name Index, Prev: GNU Free Documentation License, Up: Top
4959 * !=: Setting. (line 6)
4960 * !=, expansion: Reading Makefiles. (line 33)
4961 * # (comments), in makefile: Makefile Contents. (line 42)
4962 * # (comments), in recipes: Recipe Syntax. (line 29)
4963 * #include: Automatic Prerequisites.
4965 * $, in function call: Syntax of Functions. (line 6)
4966 * $, in rules: Rule Syntax. (line 34)
4967 * $, in variable name: Computed Names. (line 6)
4968 * $, in variable reference: Reference. (line 6)
4969 * %, in pattern rules: Pattern Intro. (line 9)
4970 * %, quoting in patsubst: Text Functions. (line 26)
4971 * %, quoting in static pattern: Static Usage. (line 37)
4972 * %, quoting in vpath: Selective Search. (line 38)
4973 * %, quoting with \ (backslash) <1>: Text Functions. (line 26)
4974 * %, quoting with \ (backslash) <2>: Static Usage. (line 37)
4975 * %, quoting with \ (backslash): Selective Search. (line 38)
4976 * * (wildcard character): Wildcards. (line 6)
4977 * +, and define: Canned Recipes. (line 49)
4978 * +, and recipe execution: Instead of Execution.
4980 * +, and recipes: MAKE Variable. (line 18)
4981 * +=: Appending. (line 6)
4982 * +=, expansion: Reading Makefiles. (line 33)
4983 * ,v (RCS file extension): Catalogue of Rules. (line 164)
4984 * - (in recipes): Errors. (line 19)
4985 * -, and define: Canned Recipes. (line 49)
4986 * --always-make: Options Summary. (line 15)
4987 * --assume-new <1>: Options Summary. (line 276)
4988 * --assume-new: Instead of Execution.
4990 * --assume-new, and recursion: Options/Recursion. (line 22)
4991 * --assume-old <1>: Options Summary. (line 159)
4992 * --assume-old: Avoiding Compilation.
4994 * --assume-old, and recursion: Options/Recursion. (line 22)
4995 * --check-symlink-times: Options Summary. (line 141)
4996 * --debug: Options Summary. (line 42)
4997 * --directory <1>: Options Summary. (line 26)
4998 * --directory: Recursion. (line 20)
4999 * --directory, and --print-directory: -w Option. (line 20)
5000 * --directory, and recursion: Options/Recursion. (line 22)
5001 * --dry-run <1>: Options Summary. (line 151)
5002 * --dry-run <2>: Instead of Execution.
5004 * --dry-run: Echoing. (line 18)
5005 * --environment-overrides: Options Summary. (line 83)
5006 * --eval: Options Summary. (line 88)
5007 * --file <1>: Options Summary. (line 95)
5008 * --file <2>: Makefile Arguments. (line 6)
5009 * --file: Makefile Names. (line 23)
5010 * --file, and recursion: Options/Recursion. (line 22)
5011 * --help: Options Summary. (line 101)
5012 * --ignore-errors <1>: Options Summary. (line 105)
5013 * --ignore-errors: Errors. (line 30)
5014 * --include-dir <1>: Options Summary. (line 110)
5015 * --include-dir: Include. (line 53)
5016 * --jobs <1>: Options Summary. (line 117)
5017 * --jobs: Parallel. (line 6)
5018 * --jobs, and recursion: Options/Recursion. (line 25)
5019 * --just-print <1>: Options Summary. (line 150)
5020 * --just-print <2>: Instead of Execution.
5022 * --just-print: Echoing. (line 18)
5023 * --keep-going <1>: Options Summary. (line 126)
5024 * --keep-going <2>: Testing. (line 16)
5025 * --keep-going: Errors. (line 47)
5026 * --load-average <1>: Options Summary. (line 133)
5027 * --load-average: Parallel. (line 35)
5028 * --makefile <1>: Options Summary. (line 96)
5029 * --makefile <2>: Makefile Arguments. (line 6)
5030 * --makefile: Makefile Names. (line 23)
5031 * --max-load <1>: Options Summary. (line 134)
5032 * --max-load: Parallel. (line 35)
5033 * --new-file <1>: Options Summary. (line 275)
5034 * --new-file: Instead of Execution.
5036 * --new-file, and recursion: Options/Recursion. (line 22)
5037 * --no-builtin-rules: Options Summary. (line 203)
5038 * --no-builtin-variables: Options Summary. (line 216)
5039 * --no-keep-going: Options Summary. (line 231)
5040 * --no-print-directory <1>: Options Summary. (line 267)
5041 * --no-print-directory: -w Option. (line 20)
5042 * --old-file <1>: Options Summary. (line 158)
5043 * --old-file: Avoiding Compilation.
5045 * --old-file, and recursion: Options/Recursion. (line 22)
5046 * --output-sync <1>: Options Summary. (line 167)
5047 * --output-sync: Parallel Output. (line 11)
5048 * --print-data-base: Options Summary. (line 183)
5049 * --print-directory: Options Summary. (line 259)
5050 * --print-directory, and --directory: -w Option. (line 20)
5051 * --print-directory, and recursion: -w Option. (line 20)
5052 * --print-directory, disabling: -w Option. (line 20)
5053 * --question <1>: Options Summary. (line 195)
5054 * --question: Instead of Execution.
5056 * --quiet <1>: Options Summary. (line 226)
5057 * --quiet: Echoing. (line 24)
5058 * --recon <1>: Options Summary. (line 152)
5059 * --recon <2>: Instead of Execution.
5061 * --recon: Echoing. (line 18)
5062 * --silent <1>: Options Summary. (line 225)
5063 * --silent: Echoing. (line 24)
5064 * --stop: Options Summary. (line 232)
5065 * --touch <1>: Options Summary. (line 240)
5066 * --touch: Instead of Execution.
5068 * --touch, and recursion: MAKE Variable. (line 34)
5069 * --trace: Options Summary. (line 246)
5070 * --version: Options Summary. (line 254)
5071 * --warn-undefined-variables: Options Summary. (line 285)
5072 * --what-if <1>: Options Summary. (line 274)
5073 * --what-if: Instead of Execution.
5075 * -B: Options Summary. (line 14)
5076 * -b: Options Summary. (line 9)
5077 * -C <1>: Options Summary. (line 25)
5078 * -C: Recursion. (line 20)
5079 * -C, and -w: -w Option. (line 20)
5080 * -C, and recursion: Options/Recursion. (line 22)
5081 * -d: Options Summary. (line 33)
5082 * -e: Options Summary. (line 82)
5083 * -e (shell flag): Automatic Prerequisites.
5085 * -f <1>: Options Summary. (line 94)
5086 * -f <2>: Makefile Arguments. (line 6)
5087 * -f: Makefile Names. (line 23)
5088 * -f, and recursion: Options/Recursion. (line 22)
5089 * -h: Options Summary. (line 100)
5090 * -I: Options Summary. (line 109)
5091 * -i <1>: Options Summary. (line 104)
5092 * -i: Errors. (line 30)
5093 * -I: Include. (line 53)
5094 * -j <1>: Options Summary. (line 116)
5095 * -j: Parallel. (line 6)
5096 * -j, and archive update: Archive Pitfalls. (line 6)
5097 * -j, and recursion: Options/Recursion. (line 25)
5098 * -k <1>: Options Summary. (line 125)
5099 * -k <2>: Testing. (line 16)
5100 * -k: Errors. (line 47)
5101 * -L: Options Summary. (line 140)
5102 * -l: Options Summary. (line 132)
5103 * -l (library search): Libraries/Search. (line 6)
5104 * -l (load average): Parallel. (line 35)
5105 * -m: Options Summary. (line 10)
5106 * -M (to compiler): Automatic Prerequisites.
5108 * -MM (to GNU compiler): Automatic Prerequisites.
5110 * -n <1>: Options Summary. (line 149)
5111 * -n <2>: Instead of Execution.
5113 * -n: Echoing. (line 18)
5114 * -O: Options Summary. (line 166)
5115 * -o <1>: Options Summary. (line 157)
5116 * -o: Avoiding Compilation.
5118 * -O: Parallel Output. (line 11)
5119 * -o, and recursion: Options/Recursion. (line 22)
5120 * -p: Options Summary. (line 182)
5121 * -q <1>: Options Summary. (line 194)
5122 * -q: Instead of Execution.
5124 * -R: Options Summary. (line 215)
5125 * -r: Options Summary. (line 202)
5126 * -S: Options Summary. (line 230)
5127 * -s <1>: Options Summary. (line 224)
5128 * -s: Echoing. (line 24)
5129 * -t <1>: Options Summary. (line 239)
5130 * -t: Instead of Execution.
5132 * -t, and recursion: MAKE Variable. (line 34)
5133 * -v: Options Summary. (line 253)
5134 * -W: Options Summary. (line 273)
5135 * -w: Options Summary. (line 258)
5136 * -W: Instead of Execution.
5138 * -w, and -C: -w Option. (line 20)
5139 * -w, and recursion: -w Option. (line 20)
5140 * -W, and recursion: Options/Recursion. (line 22)
5141 * -w, disabling: -w Option. (line 20)
5142 * .a (archives): Archive Suffix Rules.
5144 * .C: Catalogue of Rules. (line 39)
5145 * .c: Catalogue of Rules. (line 35)
5146 * .cc: Catalogue of Rules. (line 39)
5147 * .ch: Catalogue of Rules. (line 151)
5148 * .cpp: Catalogue of Rules. (line 39)
5149 * .d: Automatic Prerequisites.
5151 * .def: Catalogue of Rules. (line 74)
5152 * .dvi: Catalogue of Rules. (line 151)
5153 * .F: Catalogue of Rules. (line 49)
5154 * .f: Catalogue of Rules. (line 49)
5155 * .info: Catalogue of Rules. (line 158)
5156 * .l: Catalogue of Rules. (line 124)
5157 * .LIBPATTERNS, and link libraries: Libraries/Search. (line 6)
5158 * .ln: Catalogue of Rules. (line 146)
5159 * .mod: Catalogue of Rules. (line 74)
5160 * .o: Catalogue of Rules. (line 35)
5161 * .ONESHELL, use of: One Shell. (line 6)
5162 * .p: Catalogue of Rules. (line 45)
5163 * .PRECIOUS intermediate files: Chained Rules. (line 56)
5164 * .r: Catalogue of Rules. (line 49)
5165 * .S: Catalogue of Rules. (line 82)
5166 * .s: Catalogue of Rules. (line 79)
5167 * .sh: Catalogue of Rules. (line 180)
5168 * .SHELLFLAGS, value of: Choosing the Shell. (line 6)
5169 * .sym: Catalogue of Rules. (line 74)
5170 * .tex: Catalogue of Rules. (line 151)
5171 * .texi: Catalogue of Rules. (line 158)
5172 * .texinfo: Catalogue of Rules. (line 158)
5173 * .txinfo: Catalogue of Rules. (line 158)
5174 * .w: Catalogue of Rules. (line 151)
5175 * .web: Catalogue of Rules. (line 151)
5176 * .y: Catalogue of Rules. (line 120)
5177 * :: rules (double-colon): Double-Colon. (line 6)
5178 * ::= <1>: Setting. (line 6)
5179 * ::=: Flavors. (line 56)
5180 * := <1>: Setting. (line 6)
5181 * :=: Flavors. (line 56)
5182 * = <1>: Setting. (line 6)
5183 * =: Flavors. (line 10)
5184 * =, expansion: Reading Makefiles. (line 33)
5185 * ? (wildcard character): Wildcards. (line 6)
5186 * ?= <1>: Setting. (line 6)
5187 * ?=: Flavors. (line 133)
5188 * ?=, expansion: Reading Makefiles. (line 33)
5189 * @ (in recipes): Echoing. (line 6)
5190 * @, and define: Canned Recipes. (line 49)
5191 * [...] (wildcard characters): Wildcards. (line 6)
5192 * \ (backslash), for continuation lines: Simple Makefile. (line 41)
5193 * \ (backslash), in recipes: Splitting Recipe Lines.
5195 * \ (backslash), to quote % <1>: Text Functions. (line 26)
5196 * \ (backslash), to quote % <2>: Static Usage. (line 37)
5197 * \ (backslash), to quote %: Selective Search. (line 38)
5198 * __.SYMDEF: Archive Symbols. (line 6)
5199 * abspath: File Name Functions. (line 121)
5200 * algorithm for directory search: Search Algorithm. (line 6)
5201 * all (standard target): Goals. (line 72)
5202 * appending to variables: Appending. (line 6)
5203 * ar: Implicit Variables. (line 40)
5204 * archive: Archives. (line 6)
5205 * archive member targets: Archive Members. (line 6)
5206 * archive symbol directory updating: Archive Symbols. (line 6)
5207 * archive, and -j: Archive Pitfalls. (line 6)
5208 * archive, and parallel execution: Archive Pitfalls. (line 6)
5209 * archive, suffix rule for: Archive Suffix Rules.
5211 * Arg list too long: Options/Recursion. (line 57)
5212 * arguments of functions: Syntax of Functions. (line 6)
5213 * as <1>: Implicit Variables. (line 43)
5214 * as: Catalogue of Rules. (line 79)
5215 * assembly, rule to compile: Catalogue of Rules. (line 79)
5216 * automatic generation of prerequisites <1>: Automatic Prerequisites.
5218 * automatic generation of prerequisites: Include. (line 51)
5219 * automatic variables: Automatic Variables. (line 6)
5220 * automatic variables in prerequisites: Automatic Variables. (line 17)
5221 * backquotes: Shell Function. (line 6)
5222 * backslash (\), for continuation lines: Simple Makefile. (line 41)
5223 * backslash (\), in recipes: Splitting Recipe Lines.
5225 * backslash (\), to quote % <1>: Text Functions. (line 26)
5226 * backslash (\), to quote % <2>: Static Usage. (line 37)
5227 * backslash (\), to quote %: Selective Search. (line 38)
5228 * backslash (\), to quote newlines: Splitting Lines. (line 6)
5229 * backslashes in pathnames and wildcard expansion: Wildcard Pitfall.
5231 * basename: File Name Functions. (line 57)
5232 * binary packages: Install Command Categories.
5234 * broken pipe: Parallel Input. (line 11)
5235 * bugs, reporting: Bugs. (line 6)
5236 * built-in special targets: Special Targets. (line 6)
5237 * C++, rule to compile: Catalogue of Rules. (line 39)
5238 * C, rule to compile: Catalogue of Rules. (line 35)
5239 * canned recipes: Canned Recipes. (line 6)
5240 * cc <1>: Implicit Variables. (line 46)
5241 * cc: Catalogue of Rules. (line 35)
5242 * cd (shell command) <1>: MAKE Variable. (line 16)
5243 * cd (shell command): Execution. (line 12)
5244 * chains of rules: Chained Rules. (line 6)
5245 * check (standard target): Goals. (line 114)
5246 * clean (standard target): Goals. (line 75)
5247 * clean target <1>: Cleanup. (line 11)
5248 * clean target: Simple Makefile. (line 85)
5249 * cleaning up: Cleanup. (line 6)
5250 * clobber (standard target): Goals. (line 86)
5251 * co <1>: Implicit Variables. (line 66)
5252 * co: Catalogue of Rules. (line 164)
5253 * combining rules by prerequisite: Combine By Prerequisite.
5255 * command expansion: Shell Function. (line 6)
5256 * command line variable definitions, and recursion: Options/Recursion.
5258 * command line variables: Overriding. (line 6)
5259 * commands, sequences of: Canned Recipes. (line 6)
5260 * comments, in makefile: Makefile Contents. (line 42)
5261 * comments, in recipes: Recipe Syntax. (line 29)
5262 * compatibility: Features. (line 6)
5263 * compatibility in exporting: Variables/Recursion. (line 105)
5264 * compilation, testing: Testing. (line 6)
5265 * computed variable name: Computed Names. (line 6)
5266 * conditional expansion: Conditional Functions.
5268 * conditional variable assignment: Flavors. (line 133)
5269 * conditionals: Conditionals. (line 6)
5270 * continuation lines: Simple Makefile. (line 41)
5271 * controlling make: Make Control Functions.
5273 * conventions for makefiles: Makefile Conventions.
5275 * convert guile types: Guile Types. (line 6)
5276 * ctangle <1>: Implicit Variables. (line 103)
5277 * ctangle: Catalogue of Rules. (line 151)
5278 * cweave <1>: Implicit Variables. (line 97)
5279 * cweave: Catalogue of Rules. (line 151)
5280 * data base of make rules: Options Summary. (line 183)
5281 * deducing recipes (implicit rules): make Deduces. (line 6)
5282 * default directories for included makefiles: Include. (line 53)
5283 * default goal <1>: Rules. (line 11)
5284 * default goal: How Make Works. (line 11)
5285 * default makefile name: Makefile Names. (line 6)
5286 * default rules, last-resort: Last Resort. (line 6)
5287 * define, expansion: Reading Makefiles. (line 33)
5288 * defining variables verbatim: Multi-Line. (line 6)
5289 * deletion of target files <1>: Interrupts. (line 6)
5290 * deletion of target files: Errors. (line 64)
5291 * directive: Makefile Contents. (line 28)
5292 * directories, creating installation: Directory Variables. (line 20)
5293 * directories, printing them: -w Option. (line 6)
5294 * directories, updating archive symbol: Archive Symbols. (line 6)
5295 * directory part: File Name Functions. (line 17)
5296 * directory search (VPATH): Directory Search. (line 6)
5297 * directory search (VPATH), and implicit rules: Implicit/Search.
5299 * directory search (VPATH), and link libraries: Libraries/Search.
5301 * directory search (VPATH), and recipes: Recipes/Search. (line 6)
5302 * directory search algorithm: Search Algorithm. (line 6)
5303 * directory search, traditional (GPATH): Search Algorithm. (line 42)
5304 * dist (standard target): Goals. (line 106)
5305 * distclean (standard target): Goals. (line 84)
5306 * dollar sign ($), in function call: Syntax of Functions. (line 6)
5307 * dollar sign ($), in rules: Rule Syntax. (line 34)
5308 * dollar sign ($), in variable name: Computed Names. (line 6)
5309 * dollar sign ($), in variable reference: Reference. (line 6)
5310 * DOS, choosing a shell in: Choosing the Shell. (line 38)
5311 * double-colon rules: Double-Colon. (line 6)
5312 * duplicate words, removing: Text Functions. (line 155)
5313 * E2BIG: Options/Recursion. (line 57)
5314 * echoing of recipes: Echoing. (line 6)
5315 * editor: Introduction. (line 22)
5316 * Emacs (M-x compile): Errors. (line 62)
5317 * empty recipes: Empty Recipes. (line 6)
5318 * empty targets: Empty Targets. (line 6)
5319 * environment: Environment. (line 6)
5320 * environment, and recursion: Variables/Recursion. (line 6)
5321 * environment, SHELL in: Choosing the Shell. (line 12)
5322 * error, stopping on: Make Control Functions.
5324 * errors (in recipes): Errors. (line 6)
5325 * errors with wildcards: Wildcard Pitfall. (line 6)
5326 * evaluating makefile syntax: Eval Function. (line 6)
5327 * example of loaded objects: Loaded Object Example.
5329 * example using Guile: Guile Example. (line 6)
5330 * execution, in parallel: Parallel. (line 6)
5331 * execution, instead of: Instead of Execution.
5333 * execution, of recipes: Execution. (line 6)
5334 * exit status (errors): Errors. (line 6)
5335 * exit status of make: Running. (line 18)
5336 * expansion, secondary: Secondary Expansion. (line 6)
5337 * explicit rule, definition of: Makefile Contents. (line 10)
5338 * explicit rule, expansion: Reading Makefiles. (line 92)
5339 * explicit rules, secondary expansion of: Secondary Expansion.
5341 * exporting variables: Variables/Recursion. (line 6)
5342 * extensions, Guile: Guile Integration. (line 6)
5343 * extensions, load directive: load Directive. (line 6)
5344 * extensions, loading: Loading Objects. (line 6)
5345 * f77 <1>: Implicit Variables. (line 57)
5346 * f77: Catalogue of Rules. (line 49)
5347 * FDL, GNU Free Documentation License: GNU Free Documentation License.
5349 * features of GNU make: Features. (line 6)
5350 * features, missing: Missing. (line 6)
5351 * file name functions: File Name Functions. (line 6)
5352 * file name of makefile: Makefile Names. (line 6)
5353 * file name of makefile, how to specify: Makefile Names. (line 30)
5354 * file name prefix, adding: File Name Functions. (line 79)
5355 * file name suffix: File Name Functions. (line 43)
5356 * file name suffix, adding: File Name Functions. (line 68)
5357 * file name with wildcards: Wildcards. (line 6)
5358 * file name, abspath of: File Name Functions. (line 121)
5359 * file name, basename of: File Name Functions. (line 57)
5360 * file name, directory part: File Name Functions. (line 17)
5361 * file name, nondirectory part: File Name Functions. (line 27)
5362 * file name, realpath of: File Name Functions. (line 114)
5363 * file, writing to: File Function. (line 6)
5364 * files, assuming new: Instead of Execution.
5366 * files, assuming old: Avoiding Compilation.
5368 * files, avoiding recompilation of: Avoiding Compilation.
5370 * files, intermediate: Chained Rules. (line 16)
5371 * filtering out words: Text Functions. (line 132)
5372 * filtering words: Text Functions. (line 114)
5373 * finding strings: Text Functions. (line 103)
5374 * flags: Options Summary. (line 6)
5375 * flags for compilers: Implicit Variables. (line 6)
5376 * flavor of variable: Flavor Function. (line 6)
5377 * flavors of variables: Flavors. (line 6)
5378 * FORCE: Force Targets. (line 6)
5379 * force targets: Force Targets. (line 6)
5380 * Fortran, rule to compile: Catalogue of Rules. (line 49)
5381 * functions: Functions. (line 6)
5382 * functions, for controlling make: Make Control Functions.
5384 * functions, for file names: File Name Functions. (line 6)
5385 * functions, for text: Text Functions. (line 6)
5386 * functions, syntax of: Syntax of Functions. (line 6)
5387 * functions, user defined: Call Function. (line 6)
5388 * g++ <1>: Implicit Variables. (line 49)
5389 * g++: Catalogue of Rules. (line 39)
5390 * gcc: Catalogue of Rules. (line 35)
5391 * generating prerequisites automatically <1>: Automatic Prerequisites.
5393 * generating prerequisites automatically: Include. (line 51)
5394 * get <1>: Implicit Variables. (line 69)
5395 * get: Catalogue of Rules. (line 173)
5396 * globbing (wildcards): Wildcards. (line 6)
5397 * goal: How Make Works. (line 11)
5398 * goal, default <1>: Rules. (line 11)
5399 * goal, default: How Make Works. (line 11)
5400 * goal, how to specify: Goals. (line 6)
5401 * Guile <1>: Guile Integration. (line 6)
5402 * Guile: Guile Function. (line 6)
5403 * Guile example: Guile Example. (line 6)
5404 * guile, conversion of types: Guile Types. (line 6)
5405 * home directory: Wildcards. (line 11)
5406 * IEEE Standard 1003.2: Overview. (line 13)
5407 * ifdef, expansion: Reading Makefiles. (line 82)
5408 * ifeq, expansion: Reading Makefiles. (line 82)
5409 * ifndef, expansion: Reading Makefiles. (line 82)
5410 * ifneq, expansion: Reading Makefiles. (line 82)
5411 * implicit rule: Implicit Rules. (line 6)
5412 * implicit rule, and directory search: Implicit/Search. (line 6)
5413 * implicit rule, and VPATH: Implicit/Search. (line 6)
5414 * implicit rule, definition of: Makefile Contents. (line 16)
5415 * implicit rule, expansion: Reading Makefiles. (line 92)
5416 * implicit rule, how to use: Using Implicit. (line 6)
5417 * implicit rule, introduction to: make Deduces. (line 6)
5418 * implicit rule, predefined: Catalogue of Rules. (line 6)
5419 * implicit rule, search algorithm: Implicit Rule Search.
5421 * implicit rules, secondary expansion of: Secondary Expansion.
5423 * included makefiles, default directories: Include. (line 53)
5424 * including (MAKEFILE_LIST variable): Special Variables. (line 8)
5425 * including (MAKEFILES variable): MAKEFILES Variable. (line 6)
5426 * including other makefiles: Include. (line 6)
5427 * incompatibilities: Missing. (line 6)
5428 * Info, rule to format: Catalogue of Rules. (line 158)
5429 * inheritance, suppressing: Suppressing Inheritance.
5431 * input during parallel execution: Parallel Input. (line 6)
5432 * install (standard target): Goals. (line 92)
5433 * installation directories, creating: Directory Variables. (line 20)
5434 * installations, staged: DESTDIR. (line 6)
5435 * interface for loaded objects: Loaded Object API. (line 6)
5436 * intermediate files: Chained Rules. (line 16)
5437 * intermediate files, preserving: Chained Rules. (line 46)
5438 * intermediate targets, explicit: Special Targets. (line 44)
5439 * interrupt: Interrupts. (line 6)
5440 * job slots: Parallel. (line 6)
5441 * job slots, and recursion: Options/Recursion. (line 25)
5442 * jobs, limiting based on load: Parallel. (line 35)
5443 * joining lists of words: File Name Functions. (line 90)
5444 * killing (interruption): Interrupts. (line 6)
5445 * last-resort default rules: Last Resort. (line 6)
5446 * ld: Catalogue of Rules. (line 86)
5447 * lex <1>: Implicit Variables. (line 73)
5448 * lex: Catalogue of Rules. (line 124)
5449 * Lex, rule to run: Catalogue of Rules. (line 124)
5450 * libraries for linking, directory search: Libraries/Search. (line 6)
5451 * library archive, suffix rule for: Archive Suffix Rules.
5453 * limiting jobs based on load: Parallel. (line 35)
5454 * link libraries, and directory search: Libraries/Search. (line 6)
5455 * link libraries, patterns matching: Libraries/Search. (line 6)
5456 * linking, predefined rule for: Catalogue of Rules. (line 86)
5457 * lint <1>: Implicit Variables. (line 80)
5458 * lint: Catalogue of Rules. (line 146)
5459 * lint, rule to run: Catalogue of Rules. (line 146)
5460 * list of all prerequisites: Automatic Variables. (line 61)
5461 * list of changed prerequisites: Automatic Variables. (line 51)
5462 * load average: Parallel. (line 35)
5463 * load directive: load Directive. (line 6)
5464 * loaded object API: Loaded Object API. (line 6)
5465 * loaded object example: Loaded Object Example.
5467 * loaded object licensing: Loaded Object API. (line 32)
5468 * loaded objects: Loading Objects. (line 6)
5469 * loaded objects, remaking of: Remaking Loaded Objects.
5471 * long lines, splitting: Splitting Lines. (line 6)
5472 * loops in variable expansion: Flavors. (line 44)
5473 * lpr (shell command) <1>: Empty Targets. (line 25)
5474 * lpr (shell command): Wildcard Examples. (line 21)
5475 * m2c <1>: Implicit Variables. (line 60)
5476 * m2c: Catalogue of Rules. (line 74)
5477 * macro: Using Variables. (line 10)
5478 * make depend: Automatic Prerequisites.
5480 * make extensions: Extending make. (line 6)
5481 * make interface to guile: Guile Interface. (line 6)
5482 * make procedures in guile: Guile Interface. (line 6)
5483 * makefile: Introduction. (line 7)
5484 * makefile name: Makefile Names. (line 6)
5485 * makefile name, how to specify: Makefile Names. (line 30)
5486 * makefile rule parts: Rule Introduction. (line 6)
5487 * makefile syntax, evaluating: Eval Function. (line 6)
5488 * makefile, and MAKEFILES variable: MAKEFILES Variable. (line 6)
5489 * makefile, conventions for: Makefile Conventions.
5491 * makefile, how make processes: How Make Works. (line 6)
5492 * makefile, how to write: Makefiles. (line 6)
5493 * makefile, including: Include. (line 6)
5494 * makefile, overriding: Overriding Makefiles.
5496 * makefile, parsing: Reading Makefiles. (line 6)
5497 * makefile, remaking of: Remaking Makefiles. (line 6)
5498 * makefile, simple: Simple Makefile. (line 6)
5499 * makefiles, and MAKEFILE_LIST variable: Special Variables. (line 8)
5500 * makefiles, and special variables: Special Variables. (line 6)
5501 * makeinfo <1>: Implicit Variables. (line 84)
5502 * makeinfo: Catalogue of Rules. (line 158)
5503 * match-anything rule: Match-Anything Rules.
5505 * match-anything rule, used to override: Overriding Makefiles.
5507 * missing features: Missing. (line 6)
5508 * mistakes with wildcards: Wildcard Pitfall. (line 6)
5509 * modified variable reference: Substitution Refs. (line 6)
5510 * Modula-2, rule to compile: Catalogue of Rules. (line 74)
5511 * mostlyclean (standard target): Goals. (line 78)
5512 * multi-line variable definition: Multi-Line. (line 6)
5513 * multiple rules for one target: Multiple Rules. (line 6)
5514 * multiple rules for one target (::): Double-Colon. (line 6)
5515 * multiple targets: Multiple Targets. (line 6)
5516 * multiple targets, in pattern rule: Pattern Intro. (line 53)
5517 * name of makefile: Makefile Names. (line 6)
5518 * name of makefile, how to specify: Makefile Names. (line 30)
5519 * nested variable reference: Computed Names. (line 6)
5520 * newline, quoting, in makefile: Simple Makefile. (line 41)
5521 * newline, quoting, in recipes: Splitting Recipe Lines.
5523 * nondirectory part: File Name Functions. (line 27)
5524 * normal prerequisites: Prerequisite Types. (line 6)
5525 * OBJ: Variables Simplify. (line 20)
5526 * obj: Variables Simplify. (line 20)
5527 * OBJECTS: Variables Simplify. (line 20)
5528 * objects: Variables Simplify. (line 14)
5529 * objects, loaded: Loading Objects. (line 6)
5530 * OBJS: Variables Simplify. (line 20)
5531 * objs: Variables Simplify. (line 20)
5532 * old-fashioned suffix rules: Suffix Rules. (line 6)
5533 * options: Options Summary. (line 6)
5534 * options, and recursion: Options/Recursion. (line 6)
5535 * options, setting from environment: Options/Recursion. (line 81)
5536 * options, setting in makefiles: Options/Recursion. (line 81)
5537 * order of pattern rules: Pattern Match. (line 30)
5538 * order-only prerequisites: Prerequisite Types. (line 6)
5539 * origin of variable: Origin Function. (line 6)
5540 * output during parallel execution <1>: Options Summary. (line 167)
5541 * output during parallel execution: Parallel Output. (line 6)
5542 * overriding makefiles: Overriding Makefiles.
5544 * overriding variables with arguments: Overriding. (line 6)
5545 * overriding with override: Override Directive. (line 6)
5546 * parallel execution: Parallel. (line 6)
5547 * parallel execution, and archive update: Archive Pitfalls. (line 6)
5548 * parallel execution, input during: Parallel Input. (line 6)
5549 * parallel execution, output during <1>: Options Summary. (line 167)
5550 * parallel execution, output during: Parallel Output. (line 6)
5551 * parallel execution, overriding: Special Targets. (line 130)
5552 * parts of makefile rule: Rule Introduction. (line 6)
5553 * Pascal, rule to compile: Catalogue of Rules. (line 45)
5554 * pattern rule: Pattern Intro. (line 6)
5555 * pattern rule, expansion: Reading Makefiles. (line 92)
5556 * pattern rules, order of: Pattern Match. (line 30)
5557 * pattern rules, static (not implicit): Static Pattern. (line 6)
5558 * pattern rules, static, syntax of: Static Usage. (line 6)
5559 * pattern-specific variables: Pattern-specific. (line 6)
5560 * pc <1>: Implicit Variables. (line 63)
5561 * pc: Catalogue of Rules. (line 45)
5562 * phony targets: Phony Targets. (line 6)
5563 * phony targets and recipe execution: Instead of Execution.
5565 * pitfalls of wildcards: Wildcard Pitfall. (line 6)
5566 * plugin_is_GPL_compatible: Loaded Object API. (line 32)
5567 * portability: Features. (line 6)
5568 * POSIX <1>: Options/Recursion. (line 60)
5569 * POSIX: Overview. (line 13)
5570 * POSIX-conforming mode, setting: Special Targets. (line 143)
5571 * post-installation commands: Install Command Categories.
5573 * pre-installation commands: Install Command Categories.
5575 * precious targets: Special Targets. (line 29)
5576 * predefined rules and variables, printing: Options Summary. (line 183)
5577 * prefix, adding: File Name Functions. (line 79)
5578 * prerequisite: Rules. (line 6)
5579 * prerequisite pattern, implicit: Pattern Intro. (line 22)
5580 * prerequisite pattern, static (not implicit): Static Usage. (line 30)
5581 * prerequisite types: Prerequisite Types. (line 6)
5582 * prerequisite, expansion: Reading Makefiles. (line 92)
5583 * prerequisites: Rule Syntax. (line 48)
5584 * prerequisites, and automatic variables: Automatic Variables.
5586 * prerequisites, automatic generation <1>: Automatic Prerequisites.
5588 * prerequisites, automatic generation: Include. (line 51)
5589 * prerequisites, introduction to: Rule Introduction. (line 8)
5590 * prerequisites, list of all: Automatic Variables. (line 61)
5591 * prerequisites, list of changed: Automatic Variables. (line 51)
5592 * prerequisites, normal: Prerequisite Types. (line 6)
5593 * prerequisites, order-only: Prerequisite Types. (line 6)
5594 * prerequisites, varying (static pattern): Static Pattern. (line 6)
5595 * preserving intermediate files: Chained Rules. (line 46)
5596 * preserving with .PRECIOUS <1>: Chained Rules. (line 56)
5597 * preserving with .PRECIOUS: Special Targets. (line 29)
5598 * preserving with .SECONDARY: Special Targets. (line 49)
5599 * print (standard target): Goals. (line 97)
5600 * print target <1>: Empty Targets. (line 25)
5601 * print target: Wildcard Examples. (line 21)
5602 * printing directories: -w Option. (line 6)
5603 * printing messages: Make Control Functions.
5605 * printing of recipes: Echoing. (line 6)
5606 * printing user warnings: Make Control Functions.
5608 * problems and bugs, reporting: Bugs. (line 6)
5609 * problems with wildcards: Wildcard Pitfall. (line 6)
5610 * processing a makefile: How Make Works. (line 6)
5611 * question mode: Instead of Execution.
5613 * quoting %, in patsubst: Text Functions. (line 26)
5614 * quoting %, in static pattern: Static Usage. (line 37)
5615 * quoting %, in vpath: Selective Search. (line 38)
5616 * quoting newline, in makefile: Simple Makefile. (line 41)
5617 * quoting newline, in recipes: Splitting Recipe Lines.
5619 * Ratfor, rule to compile: Catalogue of Rules. (line 49)
5620 * RCS, rule to extract from: Catalogue of Rules. (line 164)
5621 * reading makefiles: Reading Makefiles. (line 6)
5622 * README: Makefile Names. (line 9)
5623 * realclean (standard target): Goals. (line 85)
5624 * realpath: File Name Functions. (line 114)
5625 * recipe: Simple Makefile. (line 74)
5626 * recipe execution, single invocation: Special Targets. (line 137)
5627 * recipe lines, single shell: One Shell. (line 6)
5628 * recipe syntax: Recipe Syntax. (line 6)
5629 * recipe, execution: Execution. (line 6)
5630 * recipes <1>: Recipes. (line 6)
5631 * recipes: Rule Syntax. (line 26)
5632 * recipes setting shell variables: Execution. (line 12)
5633 * recipes, and directory search: Recipes/Search. (line 6)
5634 * recipes, backslash (\) in: Splitting Recipe Lines.
5636 * recipes, canned: Canned Recipes. (line 6)
5637 * recipes, comments in: Recipe Syntax. (line 29)
5638 * recipes, echoing: Echoing. (line 6)
5639 * recipes, empty: Empty Recipes. (line 6)
5640 * recipes, errors in: Errors. (line 6)
5641 * recipes, execution in parallel: Parallel. (line 6)
5642 * recipes, how to write: Recipes. (line 6)
5643 * recipes, instead of executing: Instead of Execution.
5645 * recipes, introduction to: Rule Introduction. (line 8)
5646 * recipes, quoting newlines in: Splitting Recipe Lines.
5648 * recipes, splitting: Splitting Recipe Lines.
5650 * recipes, using variables in: Variables in Recipes.
5652 * recompilation: Introduction. (line 22)
5653 * recompilation, avoiding: Avoiding Compilation.
5655 * recording events with empty targets: Empty Targets. (line 6)
5656 * recursion: Recursion. (line 6)
5657 * recursion, and -C: Options/Recursion. (line 22)
5658 * recursion, and -f: Options/Recursion. (line 22)
5659 * recursion, and -j: Options/Recursion. (line 25)
5660 * recursion, and -o: Options/Recursion. (line 22)
5661 * recursion, and -t: MAKE Variable. (line 34)
5662 * recursion, and -w: -w Option. (line 20)
5663 * recursion, and -W: Options/Recursion. (line 22)
5664 * recursion, and command line variable definitions: Options/Recursion.
5666 * recursion, and environment: Variables/Recursion. (line 6)
5667 * recursion, and MAKE variable: MAKE Variable. (line 6)
5668 * recursion, and MAKEFILES variable: MAKEFILES Variable. (line 15)
5669 * recursion, and options: Options/Recursion. (line 6)
5670 * recursion, and printing directories: -w Option. (line 6)
5671 * recursion, and variables: Variables/Recursion. (line 6)
5672 * recursion, level of: Variables/Recursion. (line 115)
5673 * recursive variable expansion <1>: Flavors. (line 6)
5674 * recursive variable expansion: Using Variables. (line 6)
5675 * recursively expanded variables: Flavors. (line 6)
5676 * reference to variables <1>: Advanced. (line 6)
5677 * reference to variables: Reference. (line 6)
5678 * relinking: How Make Works. (line 46)
5679 * remaking loaded objects: Remaking Loaded Objects.
5681 * remaking makefiles: Remaking Makefiles. (line 6)
5682 * removal of target files <1>: Interrupts. (line 6)
5683 * removal of target files: Errors. (line 64)
5684 * removing duplicate words: Text Functions. (line 155)
5685 * removing targets on failure: Special Targets. (line 64)
5686 * removing, to clean up: Cleanup. (line 6)
5687 * reporting bugs: Bugs. (line 6)
5688 * rm: Implicit Variables. (line 106)
5689 * rm (shell command) <1>: Errors. (line 27)
5690 * rm (shell command) <2>: Phony Targets. (line 20)
5691 * rm (shell command) <3>: Wildcard Examples. (line 12)
5692 * rm (shell command): Simple Makefile. (line 85)
5693 * rule prerequisites: Rule Syntax. (line 48)
5694 * rule syntax: Rule Syntax. (line 6)
5695 * rule targets: Rule Syntax. (line 18)
5696 * rule, double-colon (::): Double-Colon. (line 6)
5697 * rule, explicit, definition of: Makefile Contents. (line 10)
5698 * rule, how to write: Rules. (line 6)
5699 * rule, implicit: Implicit Rules. (line 6)
5700 * rule, implicit, and directory search: Implicit/Search. (line 6)
5701 * rule, implicit, and VPATH: Implicit/Search. (line 6)
5702 * rule, implicit, chains of: Chained Rules. (line 6)
5703 * rule, implicit, definition of: Makefile Contents. (line 16)
5704 * rule, implicit, how to use: Using Implicit. (line 6)
5705 * rule, implicit, introduction to: make Deduces. (line 6)
5706 * rule, implicit, predefined: Catalogue of Rules. (line 6)
5707 * rule, introduction to: Rule Introduction. (line 6)
5708 * rule, multiple for one target: Multiple Rules. (line 6)
5709 * rule, no recipe or prerequisites: Force Targets. (line 6)
5710 * rule, pattern: Pattern Intro. (line 6)
5711 * rule, static pattern: Static Pattern. (line 6)
5712 * rule, static pattern versus implicit: Static versus Implicit.
5714 * rule, with multiple targets: Multiple Targets. (line 6)
5715 * rules, and $: Rule Syntax. (line 34)
5716 * s. (SCCS file prefix): Catalogue of Rules. (line 173)
5717 * SCCS, rule to extract from: Catalogue of Rules. (line 173)
5718 * search algorithm, implicit rule: Implicit Rule Search.
5720 * search path for prerequisites (VPATH): Directory Search. (line 6)
5721 * search path for prerequisites (VPATH), and implicit rules: Implicit/Search.
5723 * search path for prerequisites (VPATH), and link libraries: Libraries/Search.
5725 * searching for strings: Text Functions. (line 103)
5726 * secondary expansion: Secondary Expansion. (line 6)
5727 * secondary expansion and explicit rules: Secondary Expansion.
5729 * secondary expansion and implicit rules: Secondary Expansion.
5731 * secondary expansion and static pattern rules: Secondary Expansion.
5733 * secondary files: Chained Rules. (line 46)
5734 * secondary targets: Special Targets. (line 49)
5735 * sed (shell command): Automatic Prerequisites.
5737 * selecting a word: Text Functions. (line 159)
5738 * selecting word lists: Text Functions. (line 168)
5739 * sequences of commands: Canned Recipes. (line 6)
5740 * setting options from environment: Options/Recursion. (line 81)
5741 * setting options in makefiles: Options/Recursion. (line 81)
5742 * setting variables: Setting. (line 6)
5743 * several rules for one target: Multiple Rules. (line 6)
5744 * several targets in a rule: Multiple Targets. (line 6)
5745 * shar (standard target): Goals. (line 103)
5746 * shell command, function for: Shell Function. (line 6)
5747 * shell file name pattern (in include): Include. (line 13)
5748 * shell variables, setting in recipes: Execution. (line 12)
5749 * shell wildcards (in include): Include. (line 13)
5750 * shell, choosing the: Choosing the Shell. (line 6)
5751 * SHELL, exported value: Variables/Recursion. (line 23)
5752 * SHELL, import from environment: Environment. (line 37)
5753 * shell, in DOS and Windows: Choosing the Shell. (line 38)
5754 * SHELL, MS-DOS specifics: Choosing the Shell. (line 44)
5755 * SHELL, value of: Choosing the Shell. (line 6)
5756 * signal: Interrupts. (line 6)
5757 * silent operation: Echoing. (line 6)
5758 * simple makefile: Simple Makefile. (line 6)
5759 * simple variable expansion: Using Variables. (line 6)
5760 * simplifying with variables: Variables Simplify. (line 6)
5761 * simply expanded variables: Flavors. (line 56)
5762 * sorting words: Text Functions. (line 146)
5763 * spaces, in variable values: Flavors. (line 107)
5764 * spaces, stripping: Text Functions. (line 80)
5765 * special targets: Special Targets. (line 6)
5766 * special variables: Special Variables. (line 6)
5767 * specifying makefile name: Makefile Names. (line 30)
5768 * splitting long lines: Splitting Lines. (line 6)
5769 * splitting recipes: Splitting Recipe Lines.
5771 * staged installs: DESTDIR. (line 6)
5772 * standard input: Parallel Input. (line 6)
5773 * standards conformance: Overview. (line 13)
5774 * standards for makefiles: Makefile Conventions.
5776 * static pattern rule: Static Pattern. (line 6)
5777 * static pattern rule, syntax of: Static Usage. (line 6)
5778 * static pattern rule, versus implicit: Static versus Implicit.
5780 * static pattern rules, secondary expansion of: Secondary Expansion.
5782 * stem <1>: Pattern Match. (line 6)
5783 * stem: Static Usage. (line 17)
5784 * stem, shortest: Pattern Match. (line 38)
5785 * stem, variable for: Automatic Variables. (line 77)
5786 * stopping make: Make Control Functions.
5788 * strings, searching for: Text Functions. (line 103)
5789 * stripping whitespace: Text Functions. (line 80)
5790 * sub-make: Variables/Recursion. (line 6)
5791 * subdirectories, recursion for: Recursion. (line 6)
5792 * substitution variable reference: Substitution Refs. (line 6)
5793 * suffix rule: Suffix Rules. (line 6)
5794 * suffix rule, for archive: Archive Suffix Rules.
5796 * suffix, adding: File Name Functions. (line 68)
5797 * suffix, function to find: File Name Functions. (line 43)
5798 * suffix, substituting in variables: Substitution Refs. (line 6)
5799 * suppressing inheritance: Suppressing Inheritance.
5801 * switches: Options Summary. (line 6)
5802 * symbol directories, updating archive: Archive Symbols. (line 6)
5803 * syntax of recipe: Recipe Syntax. (line 6)
5804 * syntax of rules: Rule Syntax. (line 6)
5805 * tab character (in commands): Rule Syntax. (line 26)
5806 * tabs in rules: Rule Introduction. (line 21)
5807 * TAGS (standard target): Goals. (line 111)
5808 * tangle <1>: Implicit Variables. (line 100)
5809 * tangle: Catalogue of Rules. (line 151)
5810 * tar (standard target): Goals. (line 100)
5811 * target: Rules. (line 6)
5812 * target pattern, implicit: Pattern Intro. (line 9)
5813 * target pattern, static (not implicit): Static Usage. (line 17)
5814 * target, deleting on error: Errors. (line 64)
5815 * target, deleting on interrupt: Interrupts. (line 6)
5816 * target, expansion: Reading Makefiles. (line 92)
5817 * target, multiple in pattern rule: Pattern Intro. (line 53)
5818 * target, multiple rules for one: Multiple Rules. (line 6)
5819 * target, touching: Instead of Execution.
5821 * target-specific variables: Target-specific. (line 6)
5822 * targets: Rule Syntax. (line 18)
5823 * targets without a file: Phony Targets. (line 6)
5824 * targets, built-in special: Special Targets. (line 6)
5825 * targets, empty: Empty Targets. (line 6)
5826 * targets, force: Force Targets. (line 6)
5827 * targets, introduction to: Rule Introduction. (line 8)
5828 * targets, multiple: Multiple Targets. (line 6)
5829 * targets, phony: Phony Targets. (line 6)
5830 * terminal rule: Match-Anything Rules.
5832 * test (standard target): Goals. (line 115)
5833 * testing compilation: Testing. (line 6)
5834 * tex <1>: Implicit Variables. (line 87)
5835 * tex: Catalogue of Rules. (line 151)
5836 * TeX, rule to run: Catalogue of Rules. (line 151)
5837 * texi2dvi <1>: Implicit Variables. (line 91)
5838 * texi2dvi: Catalogue of Rules. (line 158)
5839 * Texinfo, rule to format: Catalogue of Rules. (line 158)
5840 * tilde (~): Wildcards. (line 11)
5841 * touch (shell command) <1>: Empty Targets. (line 25)
5842 * touch (shell command): Wildcard Examples. (line 21)
5843 * touching files: Instead of Execution.
5845 * traditional directory search (GPATH): Search Algorithm. (line 42)
5846 * types of prerequisites: Prerequisite Types. (line 6)
5847 * types, conversion of: Guile Types. (line 6)
5848 * undefined variables, warning message: Options Summary. (line 285)
5849 * undefining variable: Undefine Directive. (line 6)
5850 * updating archive symbol directories: Archive Symbols. (line 6)
5851 * updating loaded objects: Remaking Loaded Objects.
5853 * updating makefiles: Remaking Makefiles. (line 6)
5854 * user defined functions: Call Function. (line 6)
5855 * value: Using Variables. (line 6)
5856 * value, how a variable gets it: Values. (line 6)
5857 * variable: Using Variables. (line 6)
5858 * variable definition: Makefile Contents. (line 22)
5859 * variable references in recipes: Variables in Recipes.
5861 * variables: Variables Simplify. (line 6)
5862 * variables, $ in name: Computed Names. (line 6)
5863 * variables, and implicit rule: Automatic Variables. (line 6)
5864 * variables, appending to: Appending. (line 6)
5865 * variables, automatic: Automatic Variables. (line 6)
5866 * variables, command line: Overriding. (line 6)
5867 * variables, command line, and recursion: Options/Recursion. (line 17)
5868 * variables, computed names: Computed Names. (line 6)
5869 * variables, conditional assignment: Flavors. (line 133)
5870 * variables, defining verbatim: Multi-Line. (line 6)
5871 * variables, environment <1>: Environment. (line 6)
5872 * variables, environment: Variables/Recursion. (line 6)
5873 * variables, exporting: Variables/Recursion. (line 6)
5874 * variables, flavor of: Flavor Function. (line 6)
5875 * variables, flavors: Flavors. (line 6)
5876 * variables, how they get their values: Values. (line 6)
5877 * variables, how to reference: Reference. (line 6)
5878 * variables, loops in expansion: Flavors. (line 44)
5879 * variables, modified reference: Substitution Refs. (line 6)
5880 * variables, multi-line: Multi-Line. (line 6)
5881 * variables, nested references: Computed Names. (line 6)
5882 * variables, origin of: Origin Function. (line 6)
5883 * variables, overriding: Override Directive. (line 6)
5884 * variables, overriding with arguments: Overriding. (line 6)
5885 * variables, pattern-specific: Pattern-specific. (line 6)
5886 * variables, recursively expanded: Flavors. (line 6)
5887 * variables, setting: Setting. (line 6)
5888 * variables, simply expanded: Flavors. (line 56)
5889 * variables, spaces in values: Flavors. (line 107)
5890 * variables, substituting suffix in: Substitution Refs. (line 6)
5891 * variables, substitution reference: Substitution Refs. (line 6)
5892 * variables, target-specific: Target-specific. (line 6)
5893 * variables, unexpanded value: Value Function. (line 6)
5894 * variables, warning for undefined: Options Summary. (line 285)
5895 * varying prerequisites: Static Pattern. (line 6)
5896 * verbatim variable definition: Multi-Line. (line 6)
5897 * vpath: Directory Search. (line 6)
5898 * VPATH, and implicit rules: Implicit/Search. (line 6)
5899 * VPATH, and link libraries: Libraries/Search. (line 6)
5900 * warnings, printing: Make Control Functions.
5902 * weave <1>: Implicit Variables. (line 94)
5903 * weave: Catalogue of Rules. (line 151)
5904 * Web, rule to run: Catalogue of Rules. (line 151)
5905 * what if: Instead of Execution.
5907 * whitespace, in variable values: Flavors. (line 107)
5908 * whitespace, stripping: Text Functions. (line 80)
5909 * wildcard: Wildcards. (line 6)
5910 * wildcard pitfalls: Wildcard Pitfall. (line 6)
5911 * wildcard, function: File Name Functions. (line 107)
5912 * wildcard, in archive member: Archive Members. (line 36)
5913 * wildcard, in include: Include. (line 13)
5914 * wildcards and MS-DOS/MS-Windows backslashes: Wildcard Pitfall.
5916 * Windows, choosing a shell in: Choosing the Shell. (line 38)
5917 * word, selecting a: Text Functions. (line 159)
5918 * words, extracting first: Text Functions. (line 184)
5919 * words, extracting last: Text Functions. (line 197)
5920 * words, filtering: Text Functions. (line 114)
5921 * words, filtering out: Text Functions. (line 132)
5922 * words, finding number: Text Functions. (line 180)
5923 * words, iterating over: Foreach Function. (line 6)
5924 * words, joining lists: File Name Functions. (line 90)
5925 * words, removing duplicates: Text Functions. (line 155)
5926 * words, selecting lists of: Text Functions. (line 168)
5927 * writing recipes: Recipes. (line 6)
5928 * writing rules: Rules. (line 6)
5929 * writing to a file: File Function. (line 6)
5930 * yacc <1>: Implicit Variables. (line 77)
5931 * yacc <2>: Catalogue of Rules. (line 120)
5932 * yacc: Canned Recipes. (line 18)
5933 * Yacc, rule to run: Catalogue of Rules. (line 120)
5934 * ~ (tilde): Wildcards. (line 11)
5937 File: make.info, Node: Name Index, Prev: Concept Index, Up: Top
5939 Index of Functions, Variables, & Directives
5940 *******************************************
5945 * $%: Automatic Variables. (line 37)
5946 * $(%D): Automatic Variables. (line 129)
5947 * $(%F): Automatic Variables. (line 130)
5948 * $(*D): Automatic Variables. (line 124)
5949 * $(*F): Automatic Variables. (line 125)
5950 * $(+D): Automatic Variables. (line 147)
5951 * $(+F): Automatic Variables. (line 148)
5952 * $(<D): Automatic Variables. (line 137)
5953 * $(<F): Automatic Variables. (line 138)
5954 * $(?D): Automatic Variables. (line 153)
5955 * $(?F): Automatic Variables. (line 154)
5956 * $(@D): Automatic Variables. (line 113)
5957 * $(@F): Automatic Variables. (line 119)
5958 * $(^D): Automatic Variables. (line 142)
5959 * $(^F): Automatic Variables. (line 143)
5960 * $*: Automatic Variables. (line 73)
5961 * $*, and static pattern: Static Usage. (line 81)
5962 * $+: Automatic Variables. (line 63)
5963 * $<: Automatic Variables. (line 43)
5964 * $?: Automatic Variables. (line 48)
5965 * $@: Automatic Variables. (line 30)
5966 * $^: Automatic Variables. (line 53)
5967 * $|: Automatic Variables. (line 69)
5968 * % (automatic variable): Automatic Variables. (line 37)
5969 * %D (automatic variable): Automatic Variables. (line 129)
5970 * %F (automatic variable): Automatic Variables. (line 130)
5971 * * (automatic variable): Automatic Variables. (line 73)
5972 * * (automatic variable), unsupported bizarre usage: Missing. (line 44)
5973 * *D (automatic variable): Automatic Variables. (line 124)
5974 * *F (automatic variable): Automatic Variables. (line 125)
5975 * + (automatic variable): Automatic Variables. (line 63)
5976 * +D (automatic variable): Automatic Variables. (line 147)
5977 * +F (automatic variable): Automatic Variables. (line 148)
5978 * -load: load Directive. (line 65)
5979 * .DEFAULT <1>: Last Resort. (line 23)
5980 * .DEFAULT: Special Targets. (line 20)
5981 * .DEFAULT, and empty recipes: Empty Recipes. (line 16)
5982 * .DEFAULT_GOAL (define default goal): Special Variables. (line 34)
5983 * .DELETE_ON_ERROR <1>: Errors. (line 64)
5984 * .DELETE_ON_ERROR: Special Targets. (line 63)
5985 * .EXPORT_ALL_VARIABLES <1>: Variables/Recursion. (line 99)
5986 * .EXPORT_ALL_VARIABLES: Special Targets. (line 124)
5987 * .FEATURES (list of supported features): Special Variables. (line 102)
5988 * .IGNORE <1>: Errors. (line 30)
5989 * .IGNORE: Special Targets. (line 69)
5990 * .INCLUDE_DIRS (list of include directories): Special Variables.
5992 * .INTERMEDIATE: Special Targets. (line 43)
5993 * .LIBPATTERNS: Libraries/Search. (line 6)
5994 * .LOADED: load Directive. (line 62)
5995 * .LOW_RESOLUTION_TIME: Special Targets. (line 81)
5996 * .NOTPARALLEL: Special Targets. (line 129)
5997 * .ONESHELL <1>: One Shell. (line 6)
5998 * .ONESHELL: Special Targets. (line 136)
5999 * .PHONY <1>: Special Targets. (line 8)
6000 * .PHONY: Phony Targets. (line 22)
6001 * .POSIX <1>: Options/Recursion. (line 60)
6002 * .POSIX: Special Targets. (line 142)
6003 * .PRECIOUS <1>: Interrupts. (line 22)
6004 * .PRECIOUS: Special Targets. (line 28)
6005 * .RECIPEPREFIX (change the recipe prefix character): Special Variables.
6007 * .SECONDARY: Special Targets. (line 48)
6008 * .SECONDEXPANSION <1>: Special Targets. (line 57)
6009 * .SECONDEXPANSION: Secondary Expansion. (line 6)
6010 * .SHELLFLAGS: Choosing the Shell. (line 6)
6011 * .SILENT <1>: Echoing. (line 24)
6012 * .SILENT: Special Targets. (line 111)
6013 * .SUFFIXES <1>: Suffix Rules. (line 61)
6014 * .SUFFIXES: Special Targets. (line 15)
6015 * .VARIABLES (list of variables): Special Variables. (line 93)
6016 * /usr/gnu/include: Include. (line 53)
6017 * /usr/include: Include. (line 53)
6018 * /usr/local/include: Include. (line 53)
6019 * < (automatic variable): Automatic Variables. (line 43)
6020 * <D (automatic variable): Automatic Variables. (line 137)
6021 * <F (automatic variable): Automatic Variables. (line 138)
6022 * ? (automatic variable): Automatic Variables. (line 48)
6023 * ?D (automatic variable): Automatic Variables. (line 153)
6024 * ?F (automatic variable): Automatic Variables. (line 154)
6025 * @ (automatic variable): Automatic Variables. (line 30)
6026 * @D (automatic variable): Automatic Variables. (line 113)
6027 * @F (automatic variable): Automatic Variables. (line 119)
6028 * ^ (automatic variable): Automatic Variables. (line 53)
6029 * ^D (automatic variable): Automatic Variables. (line 142)
6030 * ^F (automatic variable): Automatic Variables. (line 143)
6031 * abspath: File Name Functions. (line 121)
6032 * addprefix: File Name Functions. (line 79)
6033 * addsuffix: File Name Functions. (line 68)
6034 * and: Conditional Functions.
6036 * AR: Implicit Variables. (line 40)
6037 * ARFLAGS: Implicit Variables. (line 113)
6038 * AS: Implicit Variables. (line 43)
6039 * ASFLAGS: Implicit Variables. (line 116)
6040 * basename: File Name Functions. (line 57)
6041 * bindir: Directory Variables. (line 57)
6042 * call: Call Function. (line 6)
6043 * CC: Implicit Variables. (line 46)
6044 * CFLAGS: Implicit Variables. (line 120)
6045 * CO: Implicit Variables. (line 66)
6046 * COFLAGS: Implicit Variables. (line 126)
6047 * COMSPEC: Choosing the Shell. (line 41)
6048 * CPP: Implicit Variables. (line 52)
6049 * CPPFLAGS: Implicit Variables. (line 129)
6050 * CTANGLE: Implicit Variables. (line 103)
6051 * CURDIR: Recursion. (line 28)
6052 * CWEAVE: Implicit Variables. (line 97)
6053 * CXX: Implicit Variables. (line 49)
6054 * CXXFLAGS: Implicit Variables. (line 123)
6055 * define: Multi-Line. (line 6)
6056 * DESTDIR: DESTDIR. (line 6)
6057 * dir: File Name Functions. (line 17)
6058 * else: Conditional Syntax. (line 6)
6059 * endef: Multi-Line. (line 6)
6060 * endif: Conditional Syntax. (line 6)
6061 * error: Make Control Functions.
6063 * eval: Eval Function. (line 6)
6064 * exec_prefix: Directory Variables. (line 39)
6065 * export: Variables/Recursion. (line 40)
6066 * FC: Implicit Variables. (line 56)
6067 * FFLAGS: Implicit Variables. (line 133)
6068 * file: File Function. (line 6)
6069 * filter: Text Functions. (line 114)
6070 * filter-out: Text Functions. (line 132)
6071 * findstring: Text Functions. (line 103)
6072 * firstword: Text Functions. (line 184)
6073 * flavor: Flavor Function. (line 6)
6074 * foreach: Foreach Function. (line 6)
6075 * GET: Implicit Variables. (line 69)
6076 * GFLAGS: Implicit Variables. (line 136)
6077 * gmk-eval: Guile Interface. (line 18)
6078 * gmk-expand: Guile Interface. (line 12)
6079 * gmk_add_function: Loaded Object API. (line 54)
6080 * gmk_alloc: Loaded Object API. (line 150)
6081 * gmk_eval: Loaded Object API. (line 124)
6082 * gmk_expand: Loaded Object API. (line 118)
6083 * gmk_free: Loaded Object API. (line 155)
6084 * gmk_func_ptr: Loaded Object API. (line 96)
6085 * GNUmakefile: Makefile Names. (line 7)
6086 * GPATH: Search Algorithm. (line 48)
6087 * guile: Guile Function. (line 6)
6088 * if: Conditional Functions.
6090 * ifdef: Conditional Syntax. (line 6)
6091 * ifeq: Conditional Syntax. (line 6)
6092 * ifndef: Conditional Syntax. (line 6)
6093 * ifneq: Conditional Syntax. (line 6)
6094 * include: Include. (line 6)
6095 * info: Make Control Functions.
6097 * join: File Name Functions. (line 90)
6098 * lastword: Text Functions. (line 197)
6099 * LDFLAGS: Implicit Variables. (line 139)
6100 * LDLIBS: Implicit Variables. (line 144)
6101 * LEX: Implicit Variables. (line 72)
6102 * LFLAGS: Implicit Variables. (line 150)
6103 * libexecdir: Directory Variables. (line 70)
6104 * LINT: Implicit Variables. (line 80)
6105 * LINTFLAGS: Implicit Variables. (line 162)
6106 * load: load Directive. (line 9)
6107 * LOADLIBES: Implicit Variables. (line 144)
6108 * M2C: Implicit Variables. (line 60)
6109 * MAKE <1>: Flavors. (line 88)
6110 * MAKE: MAKE Variable. (line 6)
6111 * MAKE_HOST: Quick Reference. (line 341)
6112 * MAKE_RESTARTS (number of times make has restarted): Special Variables.
6114 * MAKE_VERSION: Quick Reference. (line 337)
6115 * MAKECMDGOALS: Goals. (line 30)
6116 * makefile: Makefile Names. (line 7)
6117 * Makefile: Makefile Names. (line 7)
6118 * MAKEFILE_LIST (list of parsed makefiles): Special Variables.
6120 * MAKEFILES <1>: Variables/Recursion. (line 127)
6121 * MAKEFILES: MAKEFILES Variable. (line 6)
6122 * MAKEFLAGS: Options/Recursion. (line 6)
6123 * MAKEINFO: Implicit Variables. (line 83)
6124 * MAKELEVEL <1>: Flavors. (line 88)
6125 * MAKELEVEL: Variables/Recursion. (line 115)
6126 * MAKEOVERRIDES: Options/Recursion. (line 49)
6127 * MAKESHELL (MS-DOS alternative to SHELL): Choosing the Shell.
6129 * MFLAGS: Options/Recursion. (line 65)
6130 * notdir: File Name Functions. (line 27)
6131 * or: Conditional Functions.
6133 * origin: Origin Function. (line 6)
6134 * OUTPUT_OPTION: Catalogue of Rules. (line 202)
6135 * override: Override Directive. (line 6)
6136 * patsubst <1>: Text Functions. (line 18)
6137 * patsubst: Substitution Refs. (line 28)
6138 * PC: Implicit Variables. (line 63)
6139 * PFLAGS: Implicit Variables. (line 156)
6140 * prefix: Directory Variables. (line 29)
6141 * private: Suppressing Inheritance.
6143 * realpath: File Name Functions. (line 114)
6144 * RFLAGS: Implicit Variables. (line 159)
6145 * RM: Implicit Variables. (line 106)
6146 * sbindir: Directory Variables. (line 63)
6147 * shell: Shell Function. (line 6)
6148 * SHELL: Choosing the Shell. (line 6)
6149 * SHELL (recipe execution): Execution. (line 6)
6150 * sort: Text Functions. (line 146)
6151 * strip: Text Functions. (line 80)
6152 * subst <1>: Text Functions. (line 9)
6153 * subst: Multiple Targets. (line 28)
6154 * suffix: File Name Functions. (line 43)
6155 * SUFFIXES: Suffix Rules. (line 81)
6156 * TANGLE: Implicit Variables. (line 100)
6157 * TEX: Implicit Variables. (line 87)
6158 * TEXI2DVI: Implicit Variables. (line 90)
6159 * undefine: Undefine Directive. (line 6)
6160 * unexport: Variables/Recursion. (line 45)
6161 * value: Value Function. (line 6)
6162 * vpath: Selective Search. (line 6)
6163 * VPATH: General Search. (line 6)
6164 * vpath: Directory Search. (line 6)
6165 * VPATH: Directory Search. (line 6)
6166 * warning: Make Control Functions.
6168 * WEAVE: Implicit Variables. (line 94)
6169 * wildcard <1>: File Name Functions. (line 107)
6170 * wildcard: Wildcard Function. (line 6)
6171 * word: Text Functions. (line 159)
6172 * wordlist: Text Functions. (line 168)
6173 * words: Text Functions. (line 180)
6174 * YACC: Implicit Variables. (line 76)
6175 * YFLAGS: Implicit Variables. (line 153)
6176 * | (automatic variable): Automatic Variables. (line 69)
projects / platform / upstream / make.git / blob