1 This is make.info, produced by makeinfo version 4.8 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.70, last updated 1 April 2006, of `The GNU Make
8 Manual', for GNU `make' version 3.81.
10 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
11 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006 Free Software
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.2 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 freedom to copy and
23 modify this GNU Manual, like GNU software. Copies published by
24 the Free Software Foundation raise funds for GNU development."
26 INFO-DIR-SECTION GNU Packages
28 * Make: (make). Remake files automatically.
32 File: make.info, Node: Pattern Rules, Next: Last Resort, Prev: Chained Rules, Up: Implicit Rules
34 10.5 Defining and Redefining Pattern Rules
35 ==========================================
37 You define an implicit rule by writing a "pattern rule". A pattern
38 rule looks like an ordinary rule, except that its target contains the
39 character `%' (exactly one of them). The target is considered a
40 pattern for matching file names; the `%' can match any nonempty
41 substring, while other characters match only themselves. The
42 prerequisites likewise use `%' to show how their names relate to the
45 Thus, a pattern rule `%.o : %.c' says how to make any file `STEM.o'
46 from another file `STEM.c'.
48 Note that expansion using `%' in pattern rules occurs *after* any
49 variable or function expansions, which take place when the makefile is
50 read. *Note How to Use Variables: Using Variables, and *Note Functions
51 for Transforming Text: Functions.
55 * Pattern Intro:: An introduction to pattern rules.
56 * Pattern Examples:: Examples of pattern rules.
57 * Automatic Variables:: How to use automatic variables in the
58 commands of implicit rules.
59 * Pattern Match:: How patterns match.
60 * Match-Anything Rules:: Precautions you should take prior to
61 defining rules that can match any
63 * Canceling Rules:: How to override or cancel built-in rules.
66 File: make.info, Node: Pattern Intro, Next: Pattern Examples, Prev: Pattern Rules, Up: Pattern Rules
68 10.5.1 Introduction to Pattern Rules
69 ------------------------------------
71 A pattern rule contains the character `%' (exactly one of them) in the
72 target; otherwise, it looks exactly like an ordinary rule. The target
73 is a pattern for matching file names; the `%' matches any nonempty
74 substring, while other characters match only themselves.
76 For example, `%.c' as a pattern matches any file name that ends in
77 `.c'. `s.%.c' as a pattern matches any file name that starts with
78 `s.', ends in `.c' and is at least five characters long. (There must
79 be at least one character to match the `%'.) The substring that the
80 `%' matches is called the "stem".
82 `%' in a prerequisite of a pattern rule stands for the same stem
83 that was matched by the `%' in the target. In order for the pattern
84 rule to apply, its target pattern must match the file name under
85 consideration and all of its prerequisites (after pattern substitution)
86 must name files that exist or can be made. These files become
87 prerequisites of the target.
89 Thus, a rule of the form
91 %.o : %.c ; COMMAND...
93 specifies how to make a file `N.o', with another file `N.c' as its
94 prerequisite, provided that `N.c' exists or can be made.
96 There may also be prerequisites that do not use `%'; such a
97 prerequisite attaches to every file made by this pattern rule. These
98 unvarying prerequisites are useful occasionally.
100 A pattern rule need not have any prerequisites that contain `%', or
101 in fact any prerequisites at all. Such a rule is effectively a general
102 wildcard. It provides a way to make any file that matches the target
103 pattern. *Note Last Resort::.
105 Pattern rules may have more than one target. Unlike normal rules,
106 this does not act as many different rules with the same prerequisites
107 and commands. If a pattern rule has multiple targets, `make' knows that
108 the rule's commands are responsible for making all of the targets. The
109 commands are executed only once to make all the targets. When searching
110 for a pattern rule to match a target, the target patterns of a rule
111 other than the one that matches the target in need of a rule are
112 incidental: `make' worries only about giving commands and prerequisites
113 to the file presently in question. However, when this file's commands
114 are run, the other targets are marked as having been updated themselves.
116 The order in which pattern rules appear in the makefile is important
117 since this is the order in which they are considered. Of equally
118 applicable rules, only the first one found is used. The rules you
119 write take precedence over those that are built in. Note however, that
120 a rule whose prerequisites actually exist or are mentioned always takes
121 priority over a rule with prerequisites that must be made by chaining
122 other implicit rules.
125 File: make.info, Node: Pattern Examples, Next: Automatic Variables, Prev: Pattern Intro, Up: Pattern Rules
127 10.5.2 Pattern Rule Examples
128 ----------------------------
130 Here are some examples of pattern rules actually predefined in `make'.
131 First, the rule that compiles `.c' files into `.o' files:
134 $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@
136 defines a rule that can make any file `X.o' from `X.c'. The command
137 uses the automatic variables `$@' and `$<' to substitute the names of
138 the target file and the source file in each case where the rule applies
139 (*note Automatic Variables::).
141 Here is a second built-in rule:
146 defines a rule that can make any file `X' whatsoever from a
147 corresponding file `X,v' in the subdirectory `RCS'. Since the target
148 is `%', this rule will apply to any file whatever, provided the
149 appropriate prerequisite file exists. The double colon makes the rule
150 "terminal", which means that its prerequisite may not be an intermediate
151 file (*note Match-Anything Pattern Rules: Match-Anything Rules.).
153 This pattern rule has two targets:
158 This tells `make' that the command `bison -d X.y' will make both
159 `X.tab.c' and `X.tab.h'. If the file `foo' depends on the files
160 `parse.tab.o' and `scan.o' and the file `scan.o' depends on the file
161 `parse.tab.h', when `parse.y' is changed, the command `bison -d parse.y'
162 will be executed only once, and the prerequisites of both `parse.tab.o'
163 and `scan.o' will be satisfied. (Presumably the file `parse.tab.o'
164 will be recompiled from `parse.tab.c' and the file `scan.o' from
165 `scan.c', while `foo' is linked from `parse.tab.o', `scan.o', and its
166 other prerequisites, and it will execute happily ever after.)
169 File: make.info, Node: Automatic Variables, Next: Pattern Match, Prev: Pattern Examples, Up: Pattern Rules
171 10.5.3 Automatic Variables
172 --------------------------
174 Suppose you are writing a pattern rule to compile a `.c' file into a
175 `.o' file: how do you write the `cc' command so that it operates on the
176 right source file name? You cannot write the name in the command,
177 because the name is different each time the implicit rule is applied.
179 What you do is use a special feature of `make', the "automatic
180 variables". These variables have values computed afresh for each rule
181 that is executed, based on the target and prerequisites of the rule.
182 In this example, you would use `$@' for the object file name and `$<'
183 for the source file name.
185 It's very important that you recognize the limited scope in which
186 automatic variable values are available: they only have values within
187 the command script. In particular, you cannot use them anywhere within
188 the target list of a rule; they have no value there and will expand to
189 the empty string. Also, they cannot be accessed directly within the
190 prerequisite list of a rule. A common mistake is attempting to use
191 `$@' within the prerequisites list; this will not work. However, there
192 is a special feature of GNU `make', secondary expansion (*note
193 Secondary Expansion::), which will allow automatic variable values to
194 be used in prerequisite lists.
196 Here is a table of automatic variables:
199 The file name of the target of the rule. If the target is an
200 archive member, then `$@' is the name of the archive file. In a
201 pattern rule that has multiple targets (*note Introduction to
202 Pattern Rules: Pattern Intro.), `$@' is the name of whichever
203 target caused the rule's commands to be run.
206 The target member name, when the target is an archive member.
207 *Note Archives::. For example, if the target is `foo.a(bar.o)'
208 then `$%' is `bar.o' and `$@' is `foo.a'. `$%' is empty when the
209 target is not an archive member.
212 The name of the first prerequisite. If the target got its
213 commands from an implicit rule, this will be the first
214 prerequisite added by the implicit rule (*note Implicit Rules::).
217 The names of all the prerequisites that are newer than the target,
218 with spaces between them. For prerequisites which are archive
219 members, only the member named is used (*note Archives::).
222 The names of all the prerequisites, with spaces between them. For
223 prerequisites which are archive members, only the member named is
224 used (*note Archives::). A target has only one prerequisite on
225 each other file it depends on, no matter how many times each file
226 is listed as a prerequisite. So if you list a prerequisite more
227 than once for a target, the value of `$^' contains just one copy
228 of the name. This list does *not* contain any of the order-only
229 prerequisites; for those see the `$|' variable, below.
232 This is like `$^', but prerequisites listed more than once are
233 duplicated in the order they were listed in the makefile. This is
234 primarily useful for use in linking commands where it is
235 meaningful to repeat library file names in a particular order.
238 The names of all the order-only prerequisites, with spaces between
242 The stem with which an implicit rule matches (*note How Patterns
243 Match: Pattern Match.). If the target is `dir/a.foo.b' and the
244 target pattern is `a.%.b' then the stem is `dir/foo'. The stem is
245 useful for constructing names of related files.
247 In a static pattern rule, the stem is part of the file name that
248 matched the `%' in the target pattern.
250 In an explicit rule, there is no stem; so `$*' cannot be determined
251 in that way. Instead, if the target name ends with a recognized
252 suffix (*note Old-Fashioned Suffix Rules: Suffix Rules.), `$*' is
253 set to the target name minus the suffix. For example, if the
254 target name is `foo.c', then `$*' is set to `foo', since `.c' is a
255 suffix. GNU `make' does this bizarre thing only for compatibility
256 with other implementations of `make'. You should generally avoid
257 using `$*' except in implicit rules or static pattern rules.
259 If the target name in an explicit rule does not end with a
260 recognized suffix, `$*' is set to the empty string for that rule.
262 `$?' is useful even in explicit rules when you wish to operate on
263 only the prerequisites that have changed. For example, suppose that an
264 archive named `lib' is supposed to contain copies of several object
265 files. This rule copies just the changed object files into the archive:
267 lib: foo.o bar.o lose.o win.o
270 Of the variables listed above, four have values that are single file
271 names, and three have values that are lists of file names. These seven
272 have variants that get just the file's directory name or just the file
273 name within the directory. The variant variables' names are formed by
274 appending `D' or `F', respectively. These variants are semi-obsolete
275 in GNU `make' since the functions `dir' and `notdir' can be used to get
276 a similar effect (*note Functions for File Names: File Name
277 Functions.). Note, however, that the `D' variants all omit the
278 trailing slash which always appears in the output of the `dir'
279 function. Here is a table of the variants:
282 The directory part of the file name of the target, with the
283 trailing slash removed. If the value of `$@' is `dir/foo.o' then
284 `$(@D)' is `dir'. This value is `.' if `$@' does not contain a
288 The file-within-directory part of the file name of the target. If
289 the value of `$@' is `dir/foo.o' then `$(@F)' is `foo.o'. `$(@F)'
290 is equivalent to `$(notdir $@)'.
294 The directory part and the file-within-directory part of the stem;
295 `dir' and `foo' in this example.
299 The directory part and the file-within-directory part of the target
300 archive member name. This makes sense only for archive member
301 targets of the form `ARCHIVE(MEMBER)' and is useful only when
302 MEMBER may contain a directory name. (*Note Archive Members as
303 Targets: Archive Members.)
307 The directory part and the file-within-directory part of the first
312 Lists of the directory parts and the file-within-directory parts
313 of all prerequisites.
317 Lists of the directory parts and the file-within-directory parts
318 of all prerequisites, including multiple instances of duplicated
323 Lists of the directory parts and the file-within-directory parts of
324 all prerequisites that are newer than the target.
326 Note that we use a special stylistic convention when we talk about
327 these automatic variables; we write "the value of `$<'", rather than
328 "the variable `<'" as we would write for ordinary variables such as
329 `objects' and `CFLAGS'. We think this convention looks more natural in
330 this special case. Please do not assume it has a deep significance;
331 `$<' refers to the variable named `<' just as `$(CFLAGS)' refers to the
332 variable named `CFLAGS'. You could just as well use `$(<)' in place of
336 File: make.info, Node: Pattern Match, Next: Match-Anything Rules, Prev: Automatic Variables, Up: Pattern Rules
338 10.5.4 How Patterns Match
339 -------------------------
341 A target pattern is composed of a `%' between a prefix and a suffix,
342 either or both of which may be empty. The pattern matches a file name
343 only if the file name starts with the prefix and ends with the suffix,
344 without overlap. The text between the prefix and the suffix is called
345 the "stem". Thus, when the pattern `%.o' matches the file name
346 `test.o', the stem is `test'. The pattern rule prerequisites are
347 turned into actual file names by substituting the stem for the character
348 `%'. Thus, if in the same example one of the prerequisites is written
349 as `%.c', it expands to `test.c'.
351 When the target pattern does not contain a slash (and it usually does
352 not), directory names in the file names are removed from the file name
353 before it is compared with the target prefix and suffix. After the
354 comparison of the file name to the target pattern, the directory names,
355 along with the slash that ends them, are added on to the prerequisite
356 file names generated from the pattern rule's prerequisite patterns and
357 the file name. The directories are ignored only for the purpose of
358 finding an implicit rule to use, not in the application of that rule.
359 Thus, `e%t' matches the file name `src/eat', with `src/a' as the stem.
360 When prerequisites are turned into file names, the directories from the
361 stem are added at the front, while the rest of the stem is substituted
362 for the `%'. The stem `src/a' with a prerequisite pattern `c%r' gives
363 the file name `src/car'.
366 File: make.info, Node: Match-Anything Rules, Next: Canceling Rules, Prev: Pattern Match, Up: Pattern Rules
368 10.5.5 Match-Anything Pattern Rules
369 -----------------------------------
371 When a pattern rule's target is just `%', it matches any file name
372 whatever. We call these rules "match-anything" rules. They are very
373 useful, but it can take a lot of time for `make' to think about them,
374 because it must consider every such rule for each file name listed
375 either as a target or as a prerequisite.
377 Suppose the makefile mentions `foo.c'. For this target, `make'
378 would have to consider making it by linking an object file `foo.c.o',
379 or by C compilation-and-linking in one step from `foo.c.c', or by
380 Pascal compilation-and-linking from `foo.c.p', and many other
383 We know these possibilities are ridiculous since `foo.c' is a C
384 source file, not an executable. If `make' did consider these
385 possibilities, it would ultimately reject them, because files such as
386 `foo.c.o' and `foo.c.p' would not exist. But these possibilities are so
387 numerous that `make' would run very slowly if it had to consider them.
389 To gain speed, we have put various constraints on the way `make'
390 considers match-anything rules. There are two different constraints
391 that can be applied, and each time you define a match-anything rule you
392 must choose one or the other for that rule.
394 One choice is to mark the match-anything rule as "terminal" by
395 defining it with a double colon. When a rule is terminal, it does not
396 apply unless its prerequisites actually exist. Prerequisites that
397 could be made with other implicit rules are not good enough. In other
398 words, no further chaining is allowed beyond a terminal rule.
400 For example, the built-in implicit rules for extracting sources from
401 RCS and SCCS files are terminal; as a result, if the file `foo.c,v' does
402 not exist, `make' will not even consider trying to make it as an
403 intermediate file from `foo.c,v.o' or from `RCS/SCCS/s.foo.c,v'. RCS
404 and SCCS files are generally ultimate source files, which should not be
405 remade from any other files; therefore, `make' can save time by not
406 looking for ways to remake them.
408 If you do not mark the match-anything rule as terminal, then it is
409 nonterminal. A nonterminal match-anything rule cannot apply to a file
410 name that indicates a specific type of data. A file name indicates a
411 specific type of data if some non-match-anything implicit rule target
414 For example, the file name `foo.c' matches the target for the pattern
415 rule `%.c : %.y' (the rule to run Yacc). Regardless of whether this
416 rule is actually applicable (which happens only if there is a file
417 `foo.y'), the fact that its target matches is enough to prevent
418 consideration of any nonterminal match-anything rules for the file
419 `foo.c'. Thus, `make' will not even consider trying to make `foo.c' as
420 an executable file from `foo.c.o', `foo.c.c', `foo.c.p', etc.
422 The motivation for this constraint is that nonterminal match-anything
423 rules are used for making files containing specific types of data (such
424 as executable files) and a file name with a recognized suffix indicates
425 some other specific type of data (such as a C source file).
427 Special built-in dummy pattern rules are provided solely to recognize
428 certain file names so that nonterminal match-anything rules will not be
429 considered. These dummy rules have no prerequisites and no commands,
430 and they are ignored for all other purposes. For example, the built-in
435 exists to make sure that Pascal source files such as `foo.p' match a
436 specific target pattern and thereby prevent time from being wasted
437 looking for `foo.p.o' or `foo.p.c'.
439 Dummy pattern rules such as the one for `%.p' are made for every
440 suffix listed as valid for use in suffix rules (*note Old-Fashioned
441 Suffix Rules: Suffix Rules.).
444 File: make.info, Node: Canceling Rules, Prev: Match-Anything Rules, Up: Pattern Rules
446 10.5.6 Canceling Implicit Rules
447 -------------------------------
449 You can override a built-in implicit rule (or one you have defined
450 yourself) by defining a new pattern rule with the same target and
451 prerequisites, but different commands. When the new rule is defined,
452 the built-in one is replaced. The new rule's position in the sequence
453 of implicit rules is determined by where you write the new rule.
455 You can cancel a built-in implicit rule by defining a pattern rule
456 with the same target and prerequisites, but no commands. For example,
457 the following would cancel the rule that runs the assembler:
462 File: make.info, Node: Last Resort, Next: Suffix Rules, Prev: Pattern Rules, Up: Implicit Rules
464 10.6 Defining Last-Resort Default Rules
465 =======================================
467 You can define a last-resort implicit rule by writing a terminal
468 match-anything pattern rule with no prerequisites (*note Match-Anything
469 Rules::). This is just like any other pattern rule; the only thing
470 special about it is that it will match any target. So such a rule's
471 commands are used for all targets and prerequisites that have no
472 commands of their own and for which no other implicit rule applies.
474 For example, when testing a makefile, you might not care if the
475 source files contain real data, only that they exist. Then you might
481 to cause all the source files needed (as prerequisites) to be created
484 You can instead define commands to be used for targets for which
485 there are no rules at all, even ones which don't specify commands. You
486 do this by writing a rule for the target `.DEFAULT'. Such a rule's
487 commands are used for all prerequisites which do not appear as targets
488 in any explicit rule, and for which no implicit rule applies.
489 Naturally, there is no `.DEFAULT' rule unless you write one.
491 If you use `.DEFAULT' with no commands or prerequisites:
495 the commands previously stored for `.DEFAULT' are cleared. Then `make'
496 acts as if you had never defined `.DEFAULT' at all.
498 If you do not want a target to get the commands from a match-anything
499 pattern rule or `.DEFAULT', but you also do not want any commands to be
500 run for the target, you can give it empty commands (*note Defining
501 Empty Commands: Empty Commands.).
503 You can use a last-resort rule to override part of another makefile.
504 *Note Overriding Part of Another Makefile: Overriding Makefiles.
507 File: make.info, Node: Suffix Rules, Next: Implicit Rule Search, Prev: Last Resort, Up: Implicit Rules
509 10.7 Old-Fashioned Suffix Rules
510 ===============================
512 "Suffix rules" are the old-fashioned way of defining implicit rules for
513 `make'. Suffix rules are obsolete because pattern rules are more
514 general and clearer. They are supported in GNU `make' for
515 compatibility with old makefiles. They come in two kinds:
516 "double-suffix" and "single-suffix".
518 A double-suffix rule is defined by a pair of suffixes: the target
519 suffix and the source suffix. It matches any file whose name ends with
520 the target suffix. The corresponding implicit prerequisite is made by
521 replacing the target suffix with the source suffix in the file name. A
522 two-suffix rule whose target and source suffixes are `.o' and `.c' is
523 equivalent to the pattern rule `%.o : %.c'.
525 A single-suffix rule is defined by a single suffix, which is the
526 source suffix. It matches any file name, and the corresponding implicit
527 prerequisite name is made by appending the source suffix. A
528 single-suffix rule whose source suffix is `.c' is equivalent to the
529 pattern rule `% : %.c'.
531 Suffix rule definitions are recognized by comparing each rule's
532 target against a defined list of known suffixes. When `make' sees a
533 rule whose target is a known suffix, this rule is considered a
534 single-suffix rule. When `make' sees a rule whose target is two known
535 suffixes concatenated, this rule is taken as a double-suffix rule.
537 For example, `.c' and `.o' are both on the default list of known
538 suffixes. Therefore, if you define a rule whose target is `.c.o',
539 `make' takes it to be a double-suffix rule with source suffix `.c' and
540 target suffix `.o'. Here is the old-fashioned way to define the rule
541 for compiling a C source file:
544 $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
546 Suffix rules cannot have any prerequisites of their own. If they
547 have any, they are treated as normal files with funny names, not as
548 suffix rules. Thus, the rule:
551 $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
553 tells how to make the file `.c.o' from the prerequisite file `foo.h',
554 and is not at all like the pattern rule:
557 $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
559 which tells how to make `.o' files from `.c' files, and makes all `.o'
560 files using this pattern rule also depend on `foo.h'.
562 Suffix rules with no commands are also meaningless. They do not
563 remove previous rules as do pattern rules with no commands (*note
564 Canceling Implicit Rules: Canceling Rules.). They simply enter the
565 suffix or pair of suffixes concatenated as a target in the data base.
567 The known suffixes are simply the names of the prerequisites of the
568 special target `.SUFFIXES'. You can add your own suffixes by writing a
569 rule for `.SUFFIXES' that adds more prerequisites, as in:
571 .SUFFIXES: .hack .win
573 which adds `.hack' and `.win' to the end of the list of suffixes.
575 If you wish to eliminate the default known suffixes instead of just
576 adding to them, write a rule for `.SUFFIXES' with no prerequisites. By
577 special dispensation, this eliminates all existing prerequisites of
578 `.SUFFIXES'. You can then write another rule to add the suffixes you
581 .SUFFIXES: # Delete the default suffixes
582 .SUFFIXES: .c .o .h # Define our suffix list
584 The `-r' or `--no-builtin-rules' flag causes the default list of
585 suffixes to be empty.
587 The variable `SUFFIXES' is defined to the default list of suffixes
588 before `make' reads any makefiles. You can change the list of suffixes
589 with a rule for the special target `.SUFFIXES', but that does not alter
593 File: make.info, Node: Implicit Rule Search, Prev: Suffix Rules, Up: Implicit Rules
595 10.8 Implicit Rule Search Algorithm
596 ===================================
598 Here is the procedure `make' uses for searching for an implicit rule
599 for a target T. This procedure is followed for each double-colon rule
600 with no commands, for each target of ordinary rules none of which have
601 commands, and for each prerequisite that is not the target of any rule.
602 It is also followed recursively for prerequisites that come from
603 implicit rules, in the search for a chain of rules.
605 Suffix rules are not mentioned in this algorithm because suffix
606 rules are converted to equivalent pattern rules once the makefiles have
609 For an archive member target of the form `ARCHIVE(MEMBER)', the
610 following algorithm is run twice, first using the entire target name T,
611 and second using `(MEMBER)' as the target T if the first run found no
614 1. Split T into a directory part, called D, and the rest, called N.
615 For example, if T is `src/foo.o', then D is `src/' and N is
618 2. Make a list of all the pattern rules one of whose targets matches
619 T or N. If the target pattern contains a slash, it is matched
620 against T; otherwise, against N.
622 3. If any rule in that list is _not_ a match-anything rule, then
623 remove all nonterminal match-anything rules from the list.
625 4. Remove from the list all rules with no commands.
627 5. For each pattern rule in the list:
629 a. Find the stem S, which is the nonempty part of T or N matched
630 by the `%' in the target pattern.
632 b. Compute the prerequisite names by substituting S for `%'; if
633 the target pattern does not contain a slash, append D to the
634 front of each prerequisite name.
636 c. Test whether all the prerequisites exist or ought to exist.
637 (If a file name is mentioned in the makefile as a target or
638 as an explicit prerequisite, then we say it ought to exist.)
640 If all prerequisites exist or ought to exist, or there are no
641 prerequisites, then this rule applies.
643 6. If no pattern rule has been found so far, try harder. For each
644 pattern rule in the list:
646 a. If the rule is terminal, ignore it and go on to the next rule.
648 b. Compute the prerequisite names as before.
650 c. Test whether all the prerequisites exist or ought to exist.
652 d. For each prerequisite that does not exist, follow this
653 algorithm recursively to see if the prerequisite can be made
656 e. If all prerequisites exist, ought to exist, or can be made by
657 implicit rules, then this rule applies.
659 7. If no implicit rule applies, the rule for `.DEFAULT', if any,
660 applies. In that case, give T the same commands that `.DEFAULT'
661 has. Otherwise, there are no commands for T.
663 Once a rule that applies has been found, for each target pattern of
664 the rule other than the one that matched T or N, the `%' in the pattern
665 is replaced with S and the resultant file name is stored until the
666 commands to remake the target file T are executed. After these
667 commands are executed, each of these stored file names are entered into
668 the data base and marked as having been updated and having the same
669 update status as the file T.
671 When the commands of a pattern rule are executed for T, the automatic
672 variables are set corresponding to the target and prerequisites. *Note
673 Automatic Variables::.
676 File: make.info, Node: Archives, Next: Features, Prev: Implicit Rules, Up: Top
678 11 Using `make' to Update Archive Files
679 ***************************************
681 "Archive files" are files containing named subfiles called "members";
682 they are maintained with the program `ar' and their main use is as
683 subroutine libraries for linking.
687 * Archive Members:: Archive members as targets.
688 * Archive Update:: The implicit rule for archive member targets.
689 * Archive Pitfalls:: Dangers to watch out for when using archives.
690 * Archive Suffix Rules:: You can write a special kind of suffix rule
691 for updating archives.
694 File: make.info, Node: Archive Members, Next: Archive Update, Prev: Archives, Up: Archives
696 11.1 Archive Members as Targets
697 ===============================
699 An individual member of an archive file can be used as a target or
700 prerequisite in `make'. You specify the member named MEMBER in archive
701 file ARCHIVE as follows:
705 This construct is available only in targets and prerequisites, not in
706 commands! Most programs that you might use in commands do not support
707 this syntax and cannot act directly on archive members. Only `ar' and
708 other programs specifically designed to operate on archives can do so.
709 Therefore, valid commands to update an archive member target probably
710 must use `ar'. For example, this rule says to create a member `hack.o'
711 in archive `foolib' by copying the file `hack.o':
713 foolib(hack.o) : hack.o
716 In fact, nearly all archive member targets are updated in just this
717 way and there is an implicit rule to do it for you. *Please note:* The
718 `c' flag to `ar' is required if the archive file does not already exist.
720 To specify several members in the same archive, you can write all the
721 member names together between the parentheses. For example:
723 foolib(hack.o kludge.o)
727 foolib(hack.o) foolib(kludge.o)
729 You can also use shell-style wildcards in an archive member
730 reference. *Note Using Wildcard Characters in File Names: Wildcards.
731 For example, `foolib(*.o)' expands to all existing members of the
732 `foolib' archive whose names end in `.o'; perhaps `foolib(hack.o)
736 File: make.info, Node: Archive Update, Next: Archive Pitfalls, Prev: Archive Members, Up: Archives
738 11.2 Implicit Rule for Archive Member Targets
739 =============================================
741 Recall that a target that looks like `A(M)' stands for the member named
742 M in the archive file A.
744 When `make' looks for an implicit rule for such a target, as a
745 special feature it considers implicit rules that match `(M)', as well as
746 those that match the actual target `A(M)'.
748 This causes one special rule whose target is `(%)' to match. This
749 rule updates the target `A(M)' by copying the file M into the archive.
750 For example, it will update the archive member target `foo.a(bar.o)' by
751 copying the _file_ `bar.o' into the archive `foo.a' as a _member_ named
754 When this rule is chained with others, the result is very powerful.
755 Thus, `make "foo.a(bar.o)"' (the quotes are needed to protect the `('
756 and `)' from being interpreted specially by the shell) in the presence
757 of a file `bar.c' is enough to cause the following commands to be run,
758 even without a makefile:
764 Here `make' has envisioned the file `bar.o' as an intermediate file.
765 *Note Chains of Implicit Rules: Chained Rules.
767 Implicit rules such as this one are written using the automatic
768 variable `$%'. *Note Automatic Variables::.
770 An archive member name in an archive cannot contain a directory
771 name, but it may be useful in a makefile to pretend that it does. If
772 you write an archive member target `foo.a(dir/file.o)', `make' will
773 perform automatic updating with this command:
775 ar r foo.a dir/file.o
777 which has the effect of copying the file `dir/file.o' into a member
778 named `file.o'. In connection with such usage, the automatic variables
779 `%D' and `%F' may be useful.
783 * Archive Symbols:: How to update archive symbol directories.
786 File: make.info, Node: Archive Symbols, Prev: Archive Update, Up: Archive Update
788 11.2.1 Updating Archive Symbol Directories
789 ------------------------------------------
791 An archive file that is used as a library usually contains a special
792 member named `__.SYMDEF' that contains a directory of the external
793 symbol names defined by all the other members. After you update any
794 other members, you need to update `__.SYMDEF' so that it will summarize
795 the other members properly. This is done by running the `ranlib'
800 Normally you would put this command in the rule for the archive file,
801 and make all the members of the archive file prerequisites of that rule.
804 libfoo.a: libfoo.a(x.o) libfoo.a(y.o) ...
807 The effect of this is to update archive members `x.o', `y.o', etc., and
808 then update the symbol directory member `__.SYMDEF' by running
809 `ranlib'. The rules for updating the members are not shown here; most
810 likely you can omit them and use the implicit rule which copies files
811 into the archive, as described in the preceding section.
813 This is not necessary when using the GNU `ar' program, which updates
814 the `__.SYMDEF' member automatically.
817 File: make.info, Node: Archive Pitfalls, Next: Archive Suffix Rules, Prev: Archive Update, Up: Archives
819 11.3 Dangers When Using Archives
820 ================================
822 It is important to be careful when using parallel execution (the `-j'
823 switch; *note Parallel Execution: Parallel.) and archives. If multiple
824 `ar' commands run at the same time on the same archive file, they will
825 not know about each other and can corrupt the file.
827 Possibly a future version of `make' will provide a mechanism to
828 circumvent this problem by serializing all commands that operate on the
829 same archive file. But for the time being, you must either write your
830 makefiles to avoid this problem in some other way, or not use `-j'.
833 File: make.info, Node: Archive Suffix Rules, Prev: Archive Pitfalls, Up: Archives
835 11.4 Suffix Rules for Archive Files
836 ===================================
838 You can write a special kind of suffix rule for dealing with archive
839 files. *Note Suffix Rules::, for a full explanation of suffix rules.
840 Archive suffix rules are obsolete in GNU `make', because pattern rules
841 for archives are a more general mechanism (*note Archive Update::).
842 But they are retained for compatibility with other `make's.
844 To write a suffix rule for archives, you simply write a suffix rule
845 using the target suffix `.a' (the usual suffix for archive files). For
846 example, here is the old-fashioned suffix rule to update a library
847 archive from C source files:
850 $(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $*.o
854 This works just as if you had written the pattern rule:
857 $(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $*.o
861 In fact, this is just what `make' does when it sees a suffix rule
862 with `.a' as the target suffix. Any double-suffix rule `.X.a' is
863 converted to a pattern rule with the target pattern `(%.o)' and a
864 prerequisite pattern of `%.X'.
866 Since you might want to use `.a' as the suffix for some other kind
867 of file, `make' also converts archive suffix rules to pattern rules in
868 the normal way (*note Suffix Rules::). Thus a double-suffix rule
869 `.X.a' produces two pattern rules: `(%.o): %.X' and `%.a: %.X'.
872 File: make.info, Node: Features, Next: Missing, Prev: Archives, Up: Top
874 12 Features of GNU `make'
875 *************************
877 Here is a summary of the features of GNU `make', for comparison with
878 and credit to other versions of `make'. We consider the features of
879 `make' in 4.2 BSD systems as a baseline. If you are concerned with
880 writing portable makefiles, you should not use the features of `make'
881 listed here, nor the ones in *Note Missing::.
883 Many features come from the version of `make' in System V.
885 * The `VPATH' variable and its special meaning. *Note Searching
886 Directories for Prerequisites: Directory Search. This feature
887 exists in System V `make', but is undocumented. It is documented
888 in 4.3 BSD `make' (which says it mimics System V's `VPATH'
891 * Included makefiles. *Note Including Other Makefiles: Include.
892 Allowing multiple files to be included with a single directive is
895 * Variables are read from and communicated via the environment.
896 *Note Variables from the Environment: Environment.
898 * Options passed through the variable `MAKEFLAGS' to recursive
899 invocations of `make'. *Note Communicating Options to a
900 Sub-`make': Options/Recursion.
902 * The automatic variable `$%' is set to the member name in an
903 archive reference. *Note Automatic Variables::.
905 * The automatic variables `$@', `$*', `$<', `$%', and `$?' have
906 corresponding forms like `$(@F)' and `$(@D)'. We have generalized
907 this to `$^' as an obvious extension. *Note Automatic Variables::.
909 * Substitution variable references. *Note Basics of Variable
910 References: Reference.
912 * The command-line options `-b' and `-m', accepted and ignored. In
913 System V `make', these options actually do something.
915 * Execution of recursive commands to run `make' via the variable
916 `MAKE' even if `-n', `-q' or `-t' is specified. *Note Recursive
917 Use of `make': Recursion.
919 * Support for suffix `.a' in suffix rules. *Note Archive Suffix
920 Rules::. This feature is obsolete in GNU `make', because the
921 general feature of rule chaining (*note Chains of Implicit Rules:
922 Chained Rules.) allows one pattern rule for installing members in
923 an archive (*note Archive Update::) to be sufficient.
925 * The arrangement of lines and backslash-newline combinations in
926 commands is retained when the commands are printed, so they appear
927 as they do in the makefile, except for the stripping of initial
930 The following features were inspired by various other versions of
931 `make'. In some cases it is unclear exactly which versions inspired
934 * Pattern rules using `%'. This has been implemented in several
935 versions of `make'. We're not sure who invented it first, but
936 it's been spread around a bit. *Note Defining and Redefining
937 Pattern Rules: Pattern Rules.
939 * Rule chaining and implicit intermediate files. This was
940 implemented by Stu Feldman in his version of `make' for AT&T
941 Eighth Edition Research Unix, and later by Andrew Hume of AT&T
942 Bell Labs in his `mk' program (where he terms it "transitive
943 closure"). We do not really know if we got this from either of
944 them or thought it up ourselves at the same time. *Note Chains of
945 Implicit Rules: Chained Rules.
947 * The automatic variable `$^' containing a list of all prerequisites
948 of the current target. We did not invent this, but we have no
949 idea who did. *Note Automatic Variables::. The automatic variable
950 `$+' is a simple extension of `$^'.
952 * The "what if" flag (`-W' in GNU `make') was (as far as we know)
953 invented by Andrew Hume in `mk'. *Note Instead of Executing the
954 Commands: Instead of Execution.
956 * The concept of doing several things at once (parallelism) exists in
957 many incarnations of `make' and similar programs, though not in the
958 System V or BSD implementations. *Note Command Execution:
961 * Modified variable references using pattern substitution come from
962 SunOS 4. *Note Basics of Variable References: Reference. This
963 functionality was provided in GNU `make' by the `patsubst'
964 function before the alternate syntax was implemented for
965 compatibility with SunOS 4. It is not altogether clear who
966 inspired whom, since GNU `make' had `patsubst' before SunOS 4 was
969 * The special significance of `+' characters preceding command lines
970 (*note Instead of Executing the Commands: Instead of Execution.) is
971 mandated by `IEEE Standard 1003.2-1992' (POSIX.2).
973 * The `+=' syntax to append to the value of a variable comes from
974 SunOS 4 `make'. *Note Appending More Text to Variables: Appending.
976 * The syntax `ARCHIVE(MEM1 MEM2...)' to list multiple members in a
977 single archive file comes from SunOS 4 `make'. *Note Archive
980 * The `-include' directive to include makefiles with no error for a
981 nonexistent file comes from SunOS 4 `make'. (But note that SunOS 4
982 `make' does not allow multiple makefiles to be specified in one
983 `-include' directive.) The same feature appears with the name
984 `sinclude' in SGI `make' and perhaps others.
986 The remaining features are inventions new in GNU `make':
988 * Use the `-v' or `--version' option to print version and copyright
991 * Use the `-h' or `--help' option to summarize the options to `make'.
993 * Simply-expanded variables. *Note The Two Flavors of Variables:
996 * Pass command-line variable assignments automatically through the
997 variable `MAKE' to recursive `make' invocations. *Note Recursive
998 Use of `make': Recursion.
1000 * Use the `-C' or `--directory' command option to change directory.
1001 *Note Summary of Options: Options Summary.
1003 * Make verbatim variable definitions with `define'. *Note Defining
1004 Variables Verbatim: Defining.
1006 * Declare phony targets with the special target `.PHONY'.
1008 Andrew Hume of AT&T Bell Labs implemented a similar feature with a
1009 different syntax in his `mk' program. This seems to be a case of
1010 parallel discovery. *Note Phony Targets: Phony Targets.
1012 * Manipulate text by calling functions. *Note Functions for
1013 Transforming Text: Functions.
1015 * Use the `-o' or `--old-file' option to pretend a file's
1016 modification-time is old. *Note Avoiding Recompilation of Some
1017 Files: Avoiding Compilation.
1019 * Conditional execution.
1021 This feature has been implemented numerous times in various
1022 versions of `make'; it seems a natural extension derived from the
1023 features of the C preprocessor and similar macro languages and is
1024 not a revolutionary concept. *Note Conditional Parts of
1025 Makefiles: Conditionals.
1027 * Specify a search path for included makefiles. *Note Including
1028 Other Makefiles: Include.
1030 * Specify extra makefiles to read with an environment variable.
1031 *Note The Variable `MAKEFILES': MAKEFILES Variable.
1033 * Strip leading sequences of `./' from file names, so that `./FILE'
1034 and `FILE' are considered to be the same file.
1036 * Use a special search method for library prerequisites written in
1037 the form `-lNAME'. *Note Directory Search for Link Libraries:
1040 * Allow suffixes for suffix rules (*note Old-Fashioned Suffix Rules:
1041 Suffix Rules.) to contain any characters. In other versions of
1042 `make', they must begin with `.' and not contain any `/'
1045 * Keep track of the current level of `make' recursion using the
1046 variable `MAKELEVEL'. *Note Recursive Use of `make': Recursion.
1048 * Provide any goals given on the command line in the variable
1049 `MAKECMDGOALS'. *Note Arguments to Specify the Goals: Goals.
1051 * Specify static pattern rules. *Note Static Pattern Rules: Static
1054 * Provide selective `vpath' search. *Note Searching Directories for
1055 Prerequisites: Directory Search.
1057 * Provide computed variable references. *Note Basics of Variable
1058 References: Reference.
1060 * Update makefiles. *Note How Makefiles Are Remade: Remaking
1061 Makefiles. System V `make' has a very, very limited form of this
1062 functionality in that it will check out SCCS files for makefiles.
1064 * Various new built-in implicit rules. *Note Catalogue of Implicit
1065 Rules: Catalogue of Rules.
1067 * The built-in variable `MAKE_VERSION' gives the version number of
1071 File: make.info, Node: Missing, Next: Makefile Conventions, Prev: Features, Up: Top
1073 13 Incompatibilities and Missing Features
1074 *****************************************
1076 The `make' programs in various other systems support a few features
1077 that are not implemented in GNU `make'. The POSIX.2 standard (`IEEE
1078 Standard 1003.2-1992') which specifies `make' does not require any of
1081 * A target of the form `FILE((ENTRY))' stands for a member of
1082 archive file FILE. The member is chosen, not by name, but by
1083 being an object file which defines the linker symbol ENTRY.
1085 This feature was not put into GNU `make' because of the
1086 nonmodularity of putting knowledge into `make' of the internal
1087 format of archive file symbol tables. *Note Updating Archive
1088 Symbol Directories: Archive Symbols.
1090 * Suffixes (used in suffix rules) that end with the character `~'
1091 have a special meaning to System V `make'; they refer to the SCCS
1092 file that corresponds to the file one would get without the `~'.
1093 For example, the suffix rule `.c~.o' would make the file `N.o' from
1094 the SCCS file `s.N.c'. For complete coverage, a whole series of
1095 such suffix rules is required. *Note Old-Fashioned Suffix Rules:
1098 In GNU `make', this entire series of cases is handled by two
1099 pattern rules for extraction from SCCS, in combination with the
1100 general feature of rule chaining. *Note Chains of Implicit Rules:
1103 * In System V and 4.3 BSD `make', files found by `VPATH' search
1104 (*note Searching Directories for Prerequisites: Directory Search.)
1105 have their names changed inside command strings. We feel it is
1106 much cleaner to always use automatic variables and thus make this
1109 * In some Unix `make's, the automatic variable `$*' appearing in the
1110 prerequisites of a rule has the amazingly strange "feature" of
1111 expanding to the full name of the _target of that rule_. We cannot
1112 imagine what went on in the minds of Unix `make' developers to do
1113 this; it is utterly inconsistent with the normal definition of
1116 * In some Unix `make's, implicit rule search (*note Using Implicit
1117 Rules: Implicit Rules.) is apparently done for _all_ targets, not
1118 just those without commands. This means you can do:
1123 and Unix `make' will intuit that `foo.o' depends on `foo.c'.
1125 We feel that such usage is broken. The prerequisite properties of
1126 `make' are well-defined (for GNU `make', at least), and doing such
1127 a thing simply does not fit the model.
1129 * GNU `make' does not include any built-in implicit rules for
1130 compiling or preprocessing EFL programs. If we hear of anyone who
1131 is using EFL, we will gladly add them.
1133 * It appears that in SVR4 `make', a suffix rule can be specified with
1134 no commands, and it is treated as if it had empty commands (*note
1135 Empty Commands::). For example:
1139 will override the built-in `.c.a' suffix rule.
1141 We feel that it is cleaner for a rule without commands to always
1142 simply add to the prerequisite list for the target. The above
1143 example can be easily rewritten to get the desired behavior in GNU
1148 * Some versions of `make' invoke the shell with the `-e' flag,
1149 except under `-k' (*note Testing the Compilation of a Program:
1150 Testing.). The `-e' flag tells the shell to exit as soon as any
1151 program it runs returns a nonzero status. We feel it is cleaner to
1152 write each shell command line to stand on its own and not require
1153 this special treatment.
1156 File: make.info, Node: Makefile Conventions, Next: Quick Reference, Prev: Missing, Up: Top
1158 14 Makefile Conventions
1159 ***********************
1161 This node describes conventions for writing the Makefiles for GNU
1162 programs. Using Automake will help you write a Makefile that follows
1167 * Makefile Basics:: General Conventions for Makefiles
1168 * Utilities in Makefiles:: Utilities in Makefiles
1169 * Command Variables:: Variables for Specifying Commands
1170 * Directory Variables:: Variables for Installation Directories
1171 * Standard Targets:: Standard Targets for Users
1172 * Install Command Categories:: Three categories of commands in the `install'
1173 rule: normal, pre-install and post-install.
1176 File: make.info, Node: Makefile Basics, Next: Utilities in Makefiles, Up: Makefile Conventions
1178 14.1 General Conventions for Makefiles
1179 ======================================
1181 Every Makefile should contain this line:
1185 to avoid trouble on systems where the `SHELL' variable might be
1186 inherited from the environment. (This is never a problem with GNU
1189 Different `make' programs have incompatible suffix lists and
1190 implicit rules, and this sometimes creates confusion or misbehavior. So
1191 it is a good idea to set the suffix list explicitly using only the
1192 suffixes you need in the particular Makefile, like this:
1197 The first line clears out the suffix list, the second introduces all
1198 suffixes which may be subject to implicit rules in this Makefile.
1200 Don't assume that `.' is in the path for command execution. When
1201 you need to run programs that are a part of your package during the
1202 make, please make sure that it uses `./' if the program is built as
1203 part of the make or `$(srcdir)/' if the file is an unchanging part of
1204 the source code. Without one of these prefixes, the current search
1207 The distinction between `./' (the "build directory") and
1208 `$(srcdir)/' (the "source directory") is important because users can
1209 build in a separate directory using the `--srcdir' option to
1210 `configure'. A rule of the form:
1212 foo.1 : foo.man sedscript
1213 sed -e sedscript foo.man > foo.1
1215 will fail when the build directory is not the source directory, because
1216 `foo.man' and `sedscript' are in the source directory.
1218 When using GNU `make', relying on `VPATH' to find the source file
1219 will work in the case where there is a single dependency file, since
1220 the `make' automatic variable `$<' will represent the source file
1221 wherever it is. (Many versions of `make' set `$<' only in implicit
1222 rules.) A Makefile target like
1225 $(CC) -I. -I$(srcdir) $(CFLAGS) -c bar.c -o foo.o
1227 should instead be written as
1230 $(CC) -I. -I$(srcdir) $(CFLAGS) -c $< -o $@
1232 in order to allow `VPATH' to work correctly. When the target has
1233 multiple dependencies, using an explicit `$(srcdir)' is the easiest way
1234 to make the rule work well. For example, the target above for `foo.1'
1237 foo.1 : foo.man sedscript
1238 sed -e $(srcdir)/sedscript $(srcdir)/foo.man > $@
1240 GNU distributions usually contain some files which are not source
1241 files--for example, Info files, and the output from Autoconf, Automake,
1242 Bison or Flex. Since these files normally appear in the source
1243 directory, they should always appear in the source directory, not in the
1244 build directory. So Makefile rules to update them should put the
1245 updated files in the source directory.
1247 However, if a file does not appear in the distribution, then the
1248 Makefile should not put it in the source directory, because building a
1249 program in ordinary circumstances should not modify the source directory
1252 Try to make the build and installation targets, at least (and all
1253 their subtargets) work correctly with a parallel `make'.
1256 File: make.info, Node: Utilities in Makefiles, Next: Command Variables, Prev: Makefile Basics, Up: Makefile Conventions
1258 14.2 Utilities in Makefiles
1259 ===========================
1261 Write the Makefile commands (and any shell scripts, such as
1262 `configure') to run in `sh', not in `csh'. Don't use any special
1263 features of `ksh' or `bash'.
1265 The `configure' script and the Makefile rules for building and
1266 installation should not use any utilities directly except these:
1268 cat cmp cp diff echo egrep expr false grep install-info
1269 ln ls mkdir mv pwd rm rmdir sed sleep sort tar test touch true
1271 The compression program `gzip' can be used in the `dist' rule.
1273 Stick to the generally supported options for these programs. For
1274 example, don't use `mkdir -p', convenient as it may be, because most
1275 systems don't support it.
1277 It is a good idea to avoid creating symbolic links in makefiles,
1278 since a few systems don't support them.
1280 The Makefile rules for building and installation can also use
1281 compilers and related programs, but should do so via `make' variables
1282 so that the user can substitute alternatives. Here are some of the
1285 ar bison cc flex install ld ldconfig lex
1286 make makeinfo ranlib texi2dvi yacc
1288 Use the following `make' variables to run those programs:
1290 $(AR) $(BISON) $(CC) $(FLEX) $(INSTALL) $(LD) $(LDCONFIG) $(LEX)
1291 $(MAKE) $(MAKEINFO) $(RANLIB) $(TEXI2DVI) $(YACC)
1293 When you use `ranlib' or `ldconfig', you should make sure nothing
1294 bad happens if the system does not have the program in question.
1295 Arrange to ignore an error from that command, and print a message before
1296 the command to tell the user that failure of this command does not mean
1297 a problem. (The Autoconf `AC_PROG_RANLIB' macro can help with this.)
1299 If you use symbolic links, you should implement a fallback for
1300 systems that don't have symbolic links.
1302 Additional utilities that can be used via Make variables are:
1304 chgrp chmod chown mknod
1306 It is ok to use other utilities in Makefile portions (or scripts)
1307 intended only for particular systems where you know those utilities
1311 File: make.info, Node: Command Variables, Next: Directory Variables, Prev: Utilities in Makefiles, Up: Makefile Conventions
1313 14.3 Variables for Specifying Commands
1314 ======================================
1316 Makefiles should provide variables for overriding certain commands,
1319 In particular, you should run most utility programs via variables.
1320 Thus, if you use Bison, have a variable named `BISON' whose default
1321 value is set with `BISON = bison', and refer to it with `$(BISON)'
1322 whenever you need to use Bison.
1324 File management utilities such as `ln', `rm', `mv', and so on, need
1325 not be referred to through variables in this way, since users don't
1326 need to replace them with other programs.
1328 Each program-name variable should come with an options variable that
1329 is used to supply options to the program. Append `FLAGS' to the
1330 program-name variable name to get the options variable name--for
1331 example, `BISONFLAGS'. (The names `CFLAGS' for the C compiler,
1332 `YFLAGS' for yacc, and `LFLAGS' for lex, are exceptions to this rule,
1333 but we keep them because they are standard.) Use `CPPFLAGS' in any
1334 compilation command that runs the preprocessor, and use `LDFLAGS' in
1335 any compilation command that does linking as well as in any direct use
1338 If there are C compiler options that _must_ be used for proper
1339 compilation of certain files, do not include them in `CFLAGS'. Users
1340 expect to be able to specify `CFLAGS' freely themselves. Instead,
1341 arrange to pass the necessary options to the C compiler independently
1342 of `CFLAGS', by writing them explicitly in the compilation commands or
1343 by defining an implicit rule, like this:
1346 ALL_CFLAGS = -I. $(CFLAGS)
1348 $(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $<
1350 Do include the `-g' option in `CFLAGS', because that is not
1351 _required_ for proper compilation. You can consider it a default that
1352 is only recommended. If the package is set up so that it is compiled
1353 with GCC by default, then you might as well include `-O' in the default
1354 value of `CFLAGS' as well.
1356 Put `CFLAGS' last in the compilation command, after other variables
1357 containing compiler options, so the user can use `CFLAGS' to override
1360 `CFLAGS' should be used in every invocation of the C compiler, both
1361 those which do compilation and those which do linking.
1363 Every Makefile should define the variable `INSTALL', which is the
1364 basic command for installing a file into the system.
1366 Every Makefile should also define the variables `INSTALL_PROGRAM'
1367 and `INSTALL_DATA'. (The default for `INSTALL_PROGRAM' should be
1368 `$(INSTALL)'; the default for `INSTALL_DATA' should be `${INSTALL} -m
1369 644'.) Then it should use those variables as the commands for actual
1370 installation, for executables and nonexecutables respectively. Use
1371 these variables as follows:
1373 $(INSTALL_PROGRAM) foo $(bindir)/foo
1374 $(INSTALL_DATA) libfoo.a $(libdir)/libfoo.a
1376 Optionally, you may prepend the value of `DESTDIR' to the target
1377 filename. Doing this allows the installer to create a snapshot of the
1378 installation to be copied onto the real target filesystem later. Do not
1379 set the value of `DESTDIR' in your Makefile, and do not include it in
1380 any installed files. With support for `DESTDIR', the above examples
1383 $(INSTALL_PROGRAM) foo $(DESTDIR)$(bindir)/foo
1384 $(INSTALL_DATA) libfoo.a $(DESTDIR)$(libdir)/libfoo.a
1386 Always use a file name, not a directory name, as the second argument of
1387 the installation commands. Use a separate command for each file to be
1391 File: make.info, Node: Directory Variables, Next: Standard Targets, Prev: Command Variables, Up: Makefile Conventions
1393 14.4 Variables for Installation Directories
1394 ===========================================
1396 Installation directories should always be named by variables, so it is
1397 easy to install in a nonstandard place. The standard names for these
1398 variables and the values they should have in GNU packages are described
1399 below. They are based on a standard filesystem layout; variants of it
1400 are used in GNU/Linux and other modern operating systems.
1402 Installers are expected to override these values when calling `make'
1403 (e.g., `make prefix=/usr install' or `configure' (e.g., `configure
1404 --prefix=/usr'). GNU packages should not try to guess which value
1405 should be appropriate for these variables on the system they are being
1406 installed onto: use the default settings specified here so that all GNU
1407 packages behave identically, allowing the installer to achieve any
1410 These two variables set the root for the installation. All the other
1411 installation directories should be subdirectories of one of these two,
1412 and nothing should be directly installed into these two directories.
1415 A prefix used in constructing the default values of the variables
1416 listed below. The default value of `prefix' should be
1417 `/usr/local'. When building the complete GNU system, the prefix
1418 will be empty and `/usr' will be a symbolic link to `/'. (If you
1419 are using Autoconf, write it as `@prefix@'.)
1421 Running `make install' with a different value of `prefix' from the
1422 one used to build the program should _not_ recompile the program.
1425 A prefix used in constructing the default values of some of the
1426 variables listed below. The default value of `exec_prefix' should
1427 be `$(prefix)'. (If you are using Autoconf, write it as
1430 Generally, `$(exec_prefix)' is used for directories that contain
1431 machine-specific files (such as executables and subroutine
1432 libraries), while `$(prefix)' is used directly for other
1435 Running `make install' with a different value of `exec_prefix'
1436 from the one used to build the program should _not_ recompile the
1439 Executable programs are installed in one of the following
1443 The directory for installing executable programs that users can
1444 run. This should normally be `/usr/local/bin', but write it as
1445 `$(exec_prefix)/bin'. (If you are using Autoconf, write it as
1449 The directory for installing executable programs that can be run
1450 from the shell, but are only generally useful to system
1451 administrators. This should normally be `/usr/local/sbin', but
1452 write it as `$(exec_prefix)/sbin'. (If you are using Autoconf,
1453 write it as `@sbindir@'.)
1456 The directory for installing executable programs to be run by other
1457 programs rather than by users. This directory should normally be
1458 `/usr/local/libexec', but write it as `$(exec_prefix)/libexec'.
1459 (If you are using Autoconf, write it as `@libexecdir@'.)
1461 The definition of `libexecdir' is the same for all packages, so
1462 you should install your data in a subdirectory thereof. Most
1463 packages install their data under `$(libexecdir)/PACKAGE-NAME/',
1464 possibly within additional subdirectories thereof, such as
1465 `$(libexecdir)/PACKAGE-NAME/MACHINE/VERSION'.
1467 Data files used by the program during its execution are divided into
1468 categories in two ways.
1470 * Some files are normally modified by programs; others are never
1471 normally modified (though users may edit some of these).
1473 * Some files are architecture-independent and can be shared by all
1474 machines at a site; some are architecture-dependent and can be
1475 shared only by machines of the same kind and operating system;
1476 others may never be shared between two machines.
1478 This makes for six different possibilities. However, we want to
1479 discourage the use of architecture-dependent files, aside from object
1480 files and libraries. It is much cleaner to make other data files
1481 architecture-independent, and it is generally not hard.
1483 Here are the variables Makefiles should use to specify directories
1484 to put these various kinds of files in:
1487 The root of the directory tree for read-only
1488 architecture-independent data files. This should normally be
1489 `/usr/local/share', but write it as `$(prefix)/share'. (If you
1490 are using Autoconf, write it as `@datarootdir@'.) `datadir''s
1491 default value is based on this variable; so are `infodir',
1492 `mandir', and others.
1495 The directory for installing idiosyncratic read-only
1496 architecture-independent data files for this program. This is
1497 usually the same place as `datarootdir', but we use the two
1498 separate variables so that you can move these program-specific
1499 files without altering the location for Info files, man pages, etc.
1501 This should normally be `/usr/local/share', but write it as
1502 `$(datarootdir)'. (If you are using Autoconf, write it as
1505 The definition of `datadir' is the same for all packages, so you
1506 should install your data in a subdirectory thereof. Most packages
1507 install their data under `$(datadir)/PACKAGE-NAME/'.
1510 The directory for installing read-only data files that pertain to a
1511 single machine-that is to say, files for configuring a host.
1512 Mailer and network configuration files, `/etc/passwd', and so
1513 forth belong here. All the files in this directory should be
1514 ordinary ASCII text files. This directory should normally be
1515 `/usr/local/etc', but write it as `$(prefix)/etc'. (If you are
1516 using Autoconf, write it as `@sysconfdir@'.)
1518 Do not install executables here in this directory (they probably
1519 belong in `$(libexecdir)' or `$(sbindir)'). Also do not install
1520 files that are modified in the normal course of their use (programs
1521 whose purpose is to change the configuration of the system
1522 excluded). Those probably belong in `$(localstatedir)'.
1525 The directory for installing architecture-independent data files
1526 which the programs modify while they run. This should normally be
1527 `/usr/local/com', but write it as `$(prefix)/com'. (If you are
1528 using Autoconf, write it as `@sharedstatedir@'.)
1531 The directory for installing data files which the programs modify
1532 while they run, and that pertain to one specific machine. Users
1533 should never need to modify files in this directory to configure
1534 the package's operation; put such configuration information in
1535 separate files that go in `$(datadir)' or `$(sysconfdir)'.
1536 `$(localstatedir)' should normally be `/usr/local/var', but write
1537 it as `$(prefix)/var'. (If you are using Autoconf, write it as
1540 These variables specify the directory for installing certain specific
1541 types of files, if your program has them. Every GNU package should
1542 have Info files, so every program needs `infodir', but not all need
1543 `libdir' or `lispdir'.
1546 The directory for installing header files to be included by user
1547 programs with the C `#include' preprocessor directive. This
1548 should normally be `/usr/local/include', but write it as
1549 `$(prefix)/include'. (If you are using Autoconf, write it as
1552 Most compilers other than GCC do not look for header files in
1553 directory `/usr/local/include'. So installing the header files
1554 this way is only useful with GCC. Sometimes this is not a problem
1555 because some libraries are only really intended to work with GCC.
1556 But some libraries are intended to work with other compilers.
1557 They should install their header files in two places, one
1558 specified by `includedir' and one specified by `oldincludedir'.
1561 The directory for installing `#include' header files for use with
1562 compilers other than GCC. This should normally be `/usr/include'.
1563 (If you are using Autoconf, you can write it as `@oldincludedir@'.)
1565 The Makefile commands should check whether the value of
1566 `oldincludedir' is empty. If it is, they should not try to use
1567 it; they should cancel the second installation of the header files.
1569 A package should not replace an existing header in this directory
1570 unless the header came from the same package. Thus, if your Foo
1571 package provides a header file `foo.h', then it should install the
1572 header file in the `oldincludedir' directory if either (1) there
1573 is no `foo.h' there or (2) the `foo.h' that exists came from the
1576 To tell whether `foo.h' came from the Foo package, put a magic
1577 string in the file--part of a comment--and `grep' for that string.
1580 The directory for installing documentation files (other than Info)
1581 for this package. By default, it should be
1582 `/usr/local/share/doc/YOURPKG', but it should be written as
1583 `$(datarootdir)/doc/YOURPKG'. (If you are using Autoconf, write
1584 it as `@docdir@'.) The YOURPKG subdirectory, which may include a
1585 version number, prevents collisions among files with common names,
1589 The directory for installing the Info files for this package. By
1590 default, it should be `/usr/local/share/info', but it should be
1591 written as `$(datarootdir)/info'. (If you are using Autoconf,
1592 write it as `@infodir@'.) `infodir' is separate from `docdir' for
1593 compatibility with existing practice.
1599 Directories for installing documentation files in the particular
1600 format. (It is not required to support documentation in all these
1601 formats.) They should all be set to `$(docdir)' by default. (If
1602 you are using Autoconf, write them as `@htmldir@', `@dvidir@',
1603 etc.) Packages which supply several translations of their
1604 documentation should install them in `$(htmldir)/'LL,
1605 `$(pdfdir)/'LL, etc. where LL is a locale abbreviation such as
1609 The directory for object files and libraries of object code. Do
1610 not install executables here, they probably ought to go in
1611 `$(libexecdir)' instead. The value of `libdir' should normally be
1612 `/usr/local/lib', but write it as `$(exec_prefix)/lib'. (If you
1613 are using Autoconf, write it as `@libdir@'.)
1616 The directory for installing any Emacs Lisp files in this package.
1617 By default, it should be `/usr/local/share/emacs/site-lisp', but
1618 it should be written as `$(datarootdir)/emacs/site-lisp'.
1620 If you are using Autoconf, write the default as `@lispdir@'. In
1621 order to make `@lispdir@' work, you need the following lines in
1622 your `configure.in' file:
1624 lispdir='${datarootdir}/emacs/site-lisp'
1628 The directory for installing locale-specific message catalogs for
1629 this package. By default, it should be `/usr/local/share/locale',
1630 but it should be written as `$(datarootdir)/locale'. (If you are
1631 using Autoconf, write it as `@localedir@'.) This directory
1632 usually has a subdirectory per locale.
1634 Unix-style man pages are installed in one of the following:
1637 The top-level directory for installing the man pages (if any) for
1638 this package. It will normally be `/usr/local/share/man', but you
1639 should write it as `$(datarootdir)/man'. (If you are using
1640 Autoconf, write it as `@mandir@'.)
1643 The directory for installing section 1 man pages. Write it as
1647 The directory for installing section 2 man pages. Write it as
1651 *Don't make the primary documentation for any GNU software be a
1652 man page. Write a manual in Texinfo instead. Man pages are just
1653 for the sake of people running GNU software on Unix, which is a
1654 secondary application only.*
1657 The file name extension for the installed man page. This should
1658 contain a period followed by the appropriate digit; it should
1662 The file name extension for installed section 1 man pages.
1665 The file name extension for installed section 2 man pages.
1668 Use these names instead of `manext' if the package needs to
1669 install man pages in more than one section of the manual.
1671 And finally, you should set the following variable:
1674 The directory for the sources being compiled. The value of this
1675 variable is normally inserted by the `configure' shell script.
1676 (If you are using Autconf, use `srcdir = @srcdir@'.)
1680 # Common prefix for installation directories.
1681 # NOTE: This directory must exist when you start the install.
1683 datarootdir = $(prefix)/share
1684 datadir = $(datarootdir)
1685 exec_prefix = $(prefix)
1686 # Where to put the executable for the command `gcc'.
1687 bindir = $(exec_prefix)/bin
1688 # Where to put the directories used by the compiler.
1689 libexecdir = $(exec_prefix)/libexec
1690 # Where to put the Info files.
1691 infodir = $(datarootdir)/info
1693 If your program installs a large number of files into one of the
1694 standard user-specified directories, it might be useful to group them
1695 into a subdirectory particular to that program. If you do this, you
1696 should write the `install' rule to create these subdirectories.
1698 Do not expect the user to include the subdirectory name in the value
1699 of any of the variables listed above. The idea of having a uniform set
1700 of variable names for installation directories is to enable the user to
1701 specify the exact same values for several different GNU packages. In
1702 order for this to be useful, all the packages must be designed so that
1703 they will work sensibly when the user does so.
1706 File: make.info, Node: Standard Targets, Next: Install Command Categories, Prev: Directory Variables, Up: Makefile Conventions
1708 14.5 Standard Targets for Users
1709 ===============================
1711 All GNU programs should have the following targets in their Makefiles:
1714 Compile the entire program. This should be the default target.
1715 This target need not rebuild any documentation files; Info files
1716 should normally be included in the distribution, and DVI files
1717 should be made only when explicitly asked for.
1719 By default, the Make rules should compile and link with `-g', so
1720 that executable programs have debugging symbols. Users who don't
1721 mind being helpless can strip the executables later if they wish.
1724 Compile the program and copy the executables, libraries, and so on
1725 to the file names where they should reside for actual use. If
1726 there is a simple test to verify that a program is properly
1727 installed, this target should run that test.
1729 Do not strip executables when installing them. Devil-may-care
1730 users can use the `install-strip' target to do that.
1732 If possible, write the `install' target rule so that it does not
1733 modify anything in the directory where the program was built,
1734 provided `make all' has just been done. This is convenient for
1735 building the program under one user name and installing it under
1738 The commands should create all the directories in which files are
1739 to be installed, if they don't already exist. This includes the
1740 directories specified as the values of the variables `prefix' and
1741 `exec_prefix', as well as all subdirectories that are needed. One
1742 way to do this is by means of an `installdirs' target as described
1745 Use `-' before any command for installing a man page, so that
1746 `make' will ignore any errors. This is in case there are systems
1747 that don't have the Unix man page documentation system installed.
1749 The way to install Info files is to copy them into `$(infodir)'
1750 with `$(INSTALL_DATA)' (*note Command Variables::), and then run
1751 the `install-info' program if it is present. `install-info' is a
1752 program that edits the Info `dir' file to add or update the menu
1753 entry for the given Info file; it is part of the Texinfo package.
1754 Here is a sample rule to install an Info file:
1756 $(DESTDIR)$(infodir)/foo.info: foo.info
1758 # There may be a newer info file in . than in srcdir.
1759 -if test -f foo.info; then d=.; \
1760 else d=$(srcdir); fi; \
1761 $(INSTALL_DATA) $$d/foo.info $(DESTDIR)$@; \
1762 # Run install-info only if it exists.
1763 # Use `if' instead of just prepending `-' to the
1764 # line so we notice real errors from install-info.
1765 # We use `$(SHELL) -c' because some shells do not
1766 # fail gracefully when there is an unknown command.
1767 if $(SHELL) -c 'install-info --version' \
1768 >/dev/null 2>&1; then \
1769 install-info --dir-file=$(DESTDIR)$(infodir)/dir \
1770 $(DESTDIR)$(infodir)/foo.info; \
1773 When writing the `install' target, you must classify all the
1774 commands into three categories: normal ones, "pre-installation"
1775 commands and "post-installation" commands. *Note Install Command
1782 These targets install documentation in formats other than Info;
1783 they're intended to be called explicitly by the person installing
1784 the package, if that format is desired. GNU prefers Info files,
1785 so these must be installed by the `install' target.
1787 When you have many documentation files to install, we recommend
1788 that you avoid collisions and clutter by arranging for these
1789 targets to install in subdirectories of the appropriate
1790 installation directory, such as `htmldir'. As one example, if
1791 your package has multiple manuals, and you wish to install HTML
1792 documentation with many files (such as the "split" mode output by
1793 `makeinfo --html'), you'll certainly want to use subdirectories,
1794 or two nodes with the same name in different manuals will
1795 overwrite each other.
1798 Delete all the installed files--the copies that the `install' and
1799 `install-*' targets create.
1801 This rule should not modify the directories where compilation is
1802 done, only the directories where files are installed.
1804 The uninstallation commands are divided into three categories,
1805 just like the installation commands. *Note Install Command
1809 Like `install', but strip the executable files while installing
1810 them. In simple cases, this target can use the `install' target in
1814 $(MAKE) INSTALL_PROGRAM='$(INSTALL_PROGRAM) -s' \
1817 But if the package installs scripts as well as real executables,
1818 the `install-strip' target can't just refer to the `install'
1819 target; it has to strip the executables but not the scripts.
1821 `install-strip' should not strip the executables in the build
1822 directory which are being copied for installation. It should only
1823 strip the copies that are installed.
1825 Normally we do not recommend stripping an executable unless you
1826 are sure the program has no bugs. However, it can be reasonable
1827 to install a stripped executable for actual execution while saving
1828 the unstripped executable elsewhere in case there is a bug.
1831 Delete all files in the current directory that are normally
1832 created by building the program. Also delete files in other
1833 directories if they are created by this makefile. However, don't
1834 delete the files that record the configuration. Also preserve
1835 files that could be made by building, but normally aren't because
1836 the distribution comes with them. There is no need to delete
1837 parent directories that were created with `mkdir -p', since they
1838 could have existed anyway.
1840 Delete `.dvi' files here if they are not part of the distribution.
1843 Delete all files in the current directory (or created by this
1844 makefile) that are created by configuring or building the program.
1845 If you have unpacked the source and built the program without
1846 creating any other files, `make distclean' should leave only the
1847 files that were in the distribution. However, there is no need to
1848 delete parent directories that were created with `mkdir -p', since
1849 they could have existed anyway.
1852 Like `clean', but may refrain from deleting a few files that people
1853 normally don't want to recompile. For example, the `mostlyclean'
1854 target for GCC does not delete `libgcc.a', because recompiling it
1855 is rarely necessary and takes a lot of time.
1858 Delete almost everything that can be reconstructed with this
1859 Makefile. This typically includes everything deleted by
1860 `distclean', plus more: C source files produced by Bison, tags
1861 tables, Info files, and so on.
1863 The reason we say "almost everything" is that running the command
1864 `make maintainer-clean' should not delete `configure' even if
1865 `configure' can be remade using a rule in the Makefile. More
1866 generally, `make maintainer-clean' should not delete anything that
1867 needs to exist in order to run `configure' and then begin to build
1868 the program. Also, there is no need to delete parent directories
1869 that were created with `mkdir -p', since they could have existed
1870 anyway. These are the only exceptions; `maintainer-clean' should
1871 delete everything else that can be rebuilt.
1873 The `maintainer-clean' target is intended to be used by a
1874 maintainer of the package, not by ordinary users. You may need
1875 special tools to reconstruct some of the files that `make
1876 maintainer-clean' deletes. Since these files are normally
1877 included in the distribution, we don't take care to make them easy
1878 to reconstruct. If you find you need to unpack the full
1879 distribution again, don't blame us.
1881 To help make users aware of this, the commands for the special
1882 `maintainer-clean' target should start with these two:
1884 @echo 'This command is intended for maintainers to use; it'
1885 @echo 'deletes files that may need special tools to rebuild.'
1888 Update a tags table for this program.
1891 Generate any Info files needed. The best way to write the rules
1896 foo.info: foo.texi chap1.texi chap2.texi
1897 $(MAKEINFO) $(srcdir)/foo.texi
1899 You must define the variable `MAKEINFO' in the Makefile. It should
1900 run the `makeinfo' program, which is part of the Texinfo
1903 Normally a GNU distribution comes with Info files, and that means
1904 the Info files are present in the source directory. Therefore,
1905 the Make rule for an info file should update it in the source
1906 directory. When users build the package, ordinarily Make will not
1907 update the Info files because they will already be up to date.
1913 Generate documentation files in the given format, if possible.
1914 Here's an example rule for generating DVI files from Texinfo:
1918 foo.dvi: foo.texi chap1.texi chap2.texi
1919 $(TEXI2DVI) $(srcdir)/foo.texi
1921 You must define the variable `TEXI2DVI' in the Makefile. It should
1922 run the program `texi2dvi', which is part of the Texinfo
1923 distribution.(1) Alternatively, write just the dependencies, and
1924 allow GNU `make' to provide the command.
1926 Here's another example, this one for generating HTML from Texinfo:
1930 foo.html: foo.texi chap1.texi chap2.texi
1931 $(TEXI2HTML) $(srcdir)/foo.texi
1933 Again, you would define the variable `TEXI2HTML' in the Makefile;
1934 for example, it might run `makeinfo --no-split --html' (`makeinfo'
1935 is part of the Texinfo distribution).
1938 Create a distribution tar file for this program. The tar file
1939 should be set up so that the file names in the tar file start with
1940 a subdirectory name which is the name of the package it is a
1941 distribution for. This name can include the version number.
1943 For example, the distribution tar file of GCC version 1.40 unpacks
1944 into a subdirectory named `gcc-1.40'.
1946 The easiest way to do this is to create a subdirectory
1947 appropriately named, use `ln' or `cp' to install the proper files
1948 in it, and then `tar' that subdirectory.
1950 Compress the tar file with `gzip'. For example, the actual
1951 distribution file for GCC version 1.40 is called `gcc-1.40.tar.gz'.
1953 The `dist' target should explicitly depend on all non-source files
1954 that are in the distribution, to make sure they are up to date in
1955 the distribution. *Note Making Releases: (standards)Releases.
1958 Perform self-tests (if any). The user must build the program
1959 before running the tests, but need not install the program; you
1960 should write the self-tests so that they work when the program is
1961 built but not installed.
1963 The following targets are suggested as conventional names, for
1964 programs in which they are useful.
1967 Perform installation tests (if any). The user must build and
1968 install the program before running the tests. You should not
1969 assume that `$(bindir)' is in the search path.
1972 It's useful to add a target named `installdirs' to create the
1973 directories where files are installed, and their parent
1974 directories. There is a script called `mkinstalldirs' which is
1975 convenient for this; you can find it in the Texinfo package. You
1976 can use a rule like this:
1978 # Make sure all installation directories (e.g. $(bindir))
1979 # actually exist by making them if necessary.
1980 installdirs: mkinstalldirs
1981 $(srcdir)/mkinstalldirs $(bindir) $(datadir) \
1982 $(libdir) $(infodir) \
1985 or, if you wish to support `DESTDIR',
1987 # Make sure all installation directories (e.g. $(bindir))
1988 # actually exist by making them if necessary.
1989 installdirs: mkinstalldirs
1990 $(srcdir)/mkinstalldirs \
1991 $(DESTDIR)$(bindir) $(DESTDIR)$(datadir) \
1992 $(DESTDIR)$(libdir) $(DESTDIR)$(infodir) \
1995 This rule should not modify the directories where compilation is
1996 done. It should do nothing but create installation directories.
1998 ---------- Footnotes ----------
2000 (1) `texi2dvi' uses TeX to do the real work of formatting. TeX is
2001 not distributed with Texinfo.
2004 File: make.info, Node: Install Command Categories, Prev: Standard Targets, Up: Makefile Conventions
2006 14.6 Install Command Categories
2007 ===============================
2009 When writing the `install' target, you must classify all the commands
2010 into three categories: normal ones, "pre-installation" commands and
2011 "post-installation" commands.
2013 Normal commands move files into their proper places, and set their
2014 modes. They may not alter any files except the ones that come entirely
2015 from the package they belong to.
2017 Pre-installation and post-installation commands may alter other
2018 files; in particular, they can edit global configuration files or data
2021 Pre-installation commands are typically executed before the normal
2022 commands, and post-installation commands are typically run after the
2025 The most common use for a post-installation command is to run
2026 `install-info'. This cannot be done with a normal command, since it
2027 alters a file (the Info directory) which does not come entirely and
2028 solely from the package being installed. It is a post-installation
2029 command because it needs to be done after the normal command which
2030 installs the package's Info files.
2032 Most programs don't need any pre-installation commands, but we have
2033 the feature just in case it is needed.
2035 To classify the commands in the `install' rule into these three
2036 categories, insert "category lines" among them. A category line
2037 specifies the category for the commands that follow.
2039 A category line consists of a tab and a reference to a special Make
2040 variable, plus an optional comment at the end. There are three
2041 variables you can use, one for each category; the variable name
2042 specifies the category. Category lines are no-ops in ordinary execution
2043 because these three Make variables are normally undefined (and you
2044 _should not_ define them in the makefile).
2046 Here are the three possible category lines, each with a comment that
2047 explains what it means:
2049 $(PRE_INSTALL) # Pre-install commands follow.
2050 $(POST_INSTALL) # Post-install commands follow.
2051 $(NORMAL_INSTALL) # Normal commands follow.
2053 If you don't use a category line at the beginning of the `install'
2054 rule, all the commands are classified as normal until the first category
2055 line. If you don't use any category lines, all the commands are
2056 classified as normal.
2058 These are the category lines for `uninstall':
2060 $(PRE_UNINSTALL) # Pre-uninstall commands follow.
2061 $(POST_UNINSTALL) # Post-uninstall commands follow.
2062 $(NORMAL_UNINSTALL) # Normal commands follow.
2064 Typically, a pre-uninstall command would be used for deleting entries
2065 from the Info directory.
2067 If the `install' or `uninstall' target has any dependencies which
2068 act as subroutines of installation, then you should start _each_
2069 dependency's commands with a category line, and start the main target's
2070 commands with a category line also. This way, you can ensure that each
2071 command is placed in the right category regardless of which of the
2072 dependencies actually run.
2074 Pre-installation and post-installation commands should not run any
2075 programs except for these:
2077 [ basename bash cat chgrp chmod chown cmp cp dd diff echo
2078 egrep expand expr false fgrep find getopt grep gunzip gzip
2079 hostname install install-info kill ldconfig ln ls md5sum
2080 mkdir mkfifo mknod mv printenv pwd rm rmdir sed sort tee
2081 test touch true uname xargs yes
2083 The reason for distinguishing the commands in this way is for the
2084 sake of making binary packages. Typically a binary package contains
2085 all the executables and other files that need to be installed, and has
2086 its own method of installing them--so it does not need to run the normal
2087 installation commands. But installing the binary package does need to
2088 execute the pre-installation and post-installation commands.
2090 Programs to build binary packages work by extracting the
2091 pre-installation and post-installation commands. Here is one way of
2092 extracting the pre-installation commands (the `-s' option to `make' is
2093 needed to silence messages about entering subdirectories):
2095 make -s -n install -o all \
2096 PRE_INSTALL=pre-install \
2097 POST_INSTALL=post-install \
2098 NORMAL_INSTALL=normal-install \
2099 | gawk -f pre-install.awk
2101 where the file `pre-install.awk' could contain this:
2103 $0 ~ /^(normal-install|post-install)[ \t]*$/ {on = 0}
2105 $0 ~ /^pre-install[ \t]*$/ {on = 1}
2108 File: make.info, Node: Quick Reference, Next: Error Messages, Prev: Makefile Conventions, Up: Top
2110 Appendix A Quick Reference
2111 **************************
2113 This appendix summarizes the directives, text manipulation functions,
2114 and special variables which GNU `make' understands. *Note Special
2115 Targets::, *Note Catalogue of Implicit Rules: Catalogue of Rules, and
2116 *Note Summary of Options: Options Summary, for other summaries.
2118 Here is a summary of the directives GNU `make' recognizes:
2122 Define a multi-line, recursively-expanded variable.
2135 Conditionally evaluate part of the makefile.
2136 *Note Conditionals::.
2141 Include another makefile.
2142 *Note Including Other Makefiles: Include.
2144 `override VARIABLE = VALUE'
2145 `override VARIABLE := VALUE'
2146 `override VARIABLE += VALUE'
2147 `override VARIABLE ?= VALUE'
2148 `override define VARIABLE'
2150 Define a variable, overriding any previous definition, even one
2151 from the command line.
2152 *Note The `override' Directive: Override Directive.
2155 Tell `make' to export all variables to child processes by default.
2156 *Note Communicating Variables to a Sub-`make': Variables/Recursion.
2159 `export VARIABLE = VALUE'
2160 `export VARIABLE := VALUE'
2161 `export VARIABLE += VALUE'
2162 `export VARIABLE ?= VALUE'
2164 Tell `make' whether or not to export a particular variable to child
2166 *Note Communicating Variables to a Sub-`make': Variables/Recursion.
2168 `vpath PATTERN PATH'
2169 Specify a search path for files matching a `%' pattern.
2170 *Note The `vpath' Directive: Selective Search.
2173 Remove all search paths previously specified for PATTERN.
2176 Remove all search paths previously specified in any `vpath'
2179 Here is a summary of the built-in functions (*note Functions::):
2181 `$(subst FROM,TO,TEXT)'
2182 Replace FROM with TO in TEXT.
2183 *Note Functions for String Substitution and Analysis: Text
2186 `$(patsubst PATTERN,REPLACEMENT,TEXT)'
2187 Replace words matching PATTERN with REPLACEMENT in TEXT.
2188 *Note Functions for String Substitution and Analysis: Text
2192 Remove excess whitespace characters from STRING.
2193 *Note Functions for String Substitution and Analysis: Text
2196 `$(findstring FIND,TEXT)'
2197 Locate FIND in TEXT.
2198 *Note Functions for String Substitution and Analysis: Text
2201 `$(filter PATTERN...,TEXT)'
2202 Select words in TEXT that match one of the PATTERN words.
2203 *Note Functions for String Substitution and Analysis: Text
2206 `$(filter-out PATTERN...,TEXT)'
2207 Select words in TEXT that _do not_ match any of the PATTERN words.
2208 *Note Functions for String Substitution and Analysis: Text
2212 Sort the words in LIST lexicographically, removing duplicates.
2213 *Note Functions for String Substitution and Analysis: Text
2217 Extract the Nth word (one-origin) of TEXT.
2218 *Note Functions for String Substitution and Analysis: Text
2222 Count the number of words in TEXT.
2223 *Note Functions for String Substitution and Analysis: Text
2226 `$(wordlist S,E,TEXT)'
2227 Returns the list of words in TEXT from S to E.
2228 *Note Functions for String Substitution and Analysis: Text
2231 `$(firstword NAMES...)'
2232 Extract the first word of NAMES.
2233 *Note Functions for String Substitution and Analysis: Text
2236 `$(lastword NAMES...)'
2237 Extract the last word of NAMES.
2238 *Note Functions for String Substitution and Analysis: Text
2242 Extract the directory part of each file name.
2243 *Note Functions for File Names: File Name Functions.
2245 `$(notdir NAMES...)'
2246 Extract the non-directory part of each file name.
2247 *Note Functions for File Names: File Name Functions.
2249 `$(suffix NAMES...)'
2250 Extract the suffix (the last `.' and following characters) of each
2252 *Note Functions for File Names: File Name Functions.
2254 `$(basename NAMES...)'
2255 Extract the base name (name without suffix) of each file name.
2256 *Note Functions for File Names: File Name Functions.
2258 `$(addsuffix SUFFIX,NAMES...)'
2259 Append SUFFIX to each word in NAMES.
2260 *Note Functions for File Names: File Name Functions.
2262 `$(addprefix PREFIX,NAMES...)'
2263 Prepend PREFIX to each word in NAMES.
2264 *Note Functions for File Names: File Name Functions.
2266 `$(join LIST1,LIST2)'
2267 Join two parallel lists of words.
2268 *Note Functions for File Names: File Name Functions.
2270 `$(wildcard PATTERN...)'
2271 Find file names matching a shell file name pattern (_not_ a `%'
2273 *Note The Function `wildcard': Wildcard Function.
2275 `$(realpath NAMES...)'
2276 For each file name in NAMES, expand to an absolute name that does
2277 not contain any `.', `..', nor symlinks.
2278 *Note Functions for File Names: File Name Functions.
2280 `$(abspath NAMES...)'
2281 For each file name in NAMES, expand to an absolute name that does
2282 not contain any `.' or `..' components, but preserves symlinks.
2283 *Note Functions for File Names: File Name Functions.
2286 When this function is evaluated, `make' generates a fatal error
2287 with the message TEXT.
2288 *Note Functions That Control Make: Make Control Functions.
2290 `$(warning TEXT...)'
2291 When this function is evaluated, `make' generates a warning with
2293 *Note Functions That Control Make: Make Control Functions.
2296 Execute a shell command and return its output.
2297 *Note The `shell' Function: Shell Function.
2299 `$(origin VARIABLE)'
2300 Return a string describing how the `make' variable VARIABLE was
2302 *Note The `origin' Function: Origin Function.
2304 `$(flavor VARIABLE)'
2305 Return a string describing the flavor of the `make' variable
2307 *Note The `flavor' Function: Flavor Function.
2309 `$(foreach VAR,WORDS,TEXT)'
2310 Evaluate TEXT with VAR bound to each word in WORDS, and
2311 concatenate the results.
2312 *Note The `foreach' Function: Foreach Function.
2314 `$(call VAR,PARAM,...)'
2315 Evaluate the variable VAR replacing any references to `$(1)',
2316 `$(2)' with the first, second, etc. PARAM values.
2317 *Note The `call' Function: Call Function.
2320 Evaluate TEXT then read the results as makefile commands. Expands
2321 to the empty string.
2322 *Note The `eval' Function: Eval Function.
2325 Evaluates to the contents of the variable VAR, with no expansion
2327 *Note The `value' Function: Value Function.
2329 Here is a summary of the automatic variables. *Note Automatic
2330 Variables::, for full information.
2333 The file name of the target.
2336 The target member name, when the target is an archive member.
2339 The name of the first prerequisite.
2342 The names of all the prerequisites that are newer than the target,
2343 with spaces between them. For prerequisites which are archive
2344 members, only the member named is used (*note Archives::).
2348 The names of all the prerequisites, with spaces between them. For
2349 prerequisites which are archive members, only the member named is
2350 used (*note Archives::). The value of `$^' omits duplicate
2351 prerequisites, while `$+' retains them and preserves their order.
2354 The stem with which an implicit rule matches (*note How Patterns
2355 Match: Pattern Match.).
2359 The directory part and the file-within-directory part of `$@'.
2363 The directory part and the file-within-directory part of `$*'.
2367 The directory part and the file-within-directory part of `$%'.
2371 The directory part and the file-within-directory part of `$<'.
2375 The directory part and the file-within-directory part of `$^'.
2379 The directory part and the file-within-directory part of `$+'.
2383 The directory part and the file-within-directory part of `$?'.
2385 These variables are used specially by GNU `make':
2388 Makefiles to be read on every invocation of `make'.
2389 *Note The Variable `MAKEFILES': MAKEFILES Variable.
2392 Directory search path for files not found in the current directory.
2393 *Note `VPATH' Search Path for All Prerequisites: General Search.
2396 The name of the system default command interpreter, usually
2397 `/bin/sh'. You can set `SHELL' in the makefile to change the
2398 shell used to run commands. *Note Command Execution: Execution.
2399 The `SHELL' variable is handled specially when importing from and
2400 exporting to the environment. *Note Choosing the Shell::.
2403 On MS-DOS only, the name of the command interpreter that is to be
2404 used by `make'. This value takes precedence over the value of
2405 `SHELL'. *Note MAKESHELL variable: Execution.
2408 The name with which `make' was invoked. Using this variable in
2409 commands has special meaning. *Note How the `MAKE' Variable
2410 Works: MAKE Variable.
2413 The number of levels of recursion (sub-`make's).
2414 *Note Variables/Recursion::.
2417 The flags given to `make'. You can set this in the environment or
2418 a makefile to set flags.
2419 *Note Communicating Options to a Sub-`make': Options/Recursion.
2421 It is _never_ appropriate to use `MAKEFLAGS' directly on a command
2422 line: its contents may not be quoted correctly for use in the
2423 shell. Always allow recursive `make''s to obtain these values
2424 through the environment from its parent.
2427 The targets given to `make' on the command line. Setting this
2428 variable has no effect on the operation of `make'.
2429 *Note Arguments to Specify the Goals: Goals.
2432 Set to the pathname of the current working directory (after all
2433 `-C' options are processed, if any). Setting this variable has no
2434 effect on the operation of `make'.
2435 *Note Recursive Use of `make': Recursion.
2438 The default list of suffixes before `make' reads any makefiles.
2441 Defines the naming of the libraries `make' searches for, and their
2443 *Note Directory Search for Link Libraries: Libraries/Search.
2446 File: make.info, Node: Error Messages, Next: Complex Makefile, Prev: Quick Reference, Up: Top
2448 Appendix B Errors Generated by Make
2449 ***********************************
2451 Here is a list of the more common errors you might see generated by
2452 `make', and some information about what they mean and how to fix them.
2454 Sometimes `make' errors are not fatal, especially in the presence of
2455 a `-' prefix on a command script line, or the `-k' command line option.
2456 Errors that are fatal are prefixed with the string `***'.
2458 Error messages are all either prefixed with the name of the program
2459 (usually `make'), or, if the error is found in a makefile, the name of
2460 the file and linenumber containing the problem.
2462 In the table below, these common prefixes are left off.
2465 `[FOO] SIGNAL DESCRIPTION'
2466 These errors are not really `make' errors at all. They mean that a
2467 program that `make' invoked as part of a command script returned a
2468 non-0 error code (`Error NN'), which `make' interprets as failure,
2469 or it exited in some other abnormal fashion (with a signal of some
2470 type). *Note Errors in Commands: Errors.
2472 If no `***' is attached to the message, then the subprocess failed
2473 but the rule in the makefile was prefixed with the `-' special
2474 character, so `make' ignored the error.
2476 `missing separator. Stop.'
2477 `missing separator (did you mean TAB instead of 8 spaces?). Stop.'
2478 This means that `make' could not understand much of anything about
2479 the command line it just read. GNU `make' looks for various kinds
2480 of separators (`:', `=', TAB characters, etc.) to help it decide
2481 what kind of commandline it's seeing. This means it couldn't find
2484 One of the most common reasons for this message is that you (or
2485 perhaps your oh-so-helpful editor, as is the case with many
2486 MS-Windows editors) have attempted to indent your command scripts
2487 with spaces instead of a TAB character. In this case, `make' will
2488 use the second form of the error above. Remember that every line
2489 in the command script must begin with a TAB character. Eight
2490 spaces do not count. *Note Rule Syntax::.
2492 `commands commence before first target. Stop.'
2493 `missing rule before commands. Stop.'
2494 This means the first thing in the makefile seems to be part of a
2495 command script: it begins with a TAB character and doesn't appear
2496 to be a legal `make' command (such as a variable assignment).
2497 Command scripts must always be associated with a target.
2499 The second form is generated if the line has a semicolon as the
2500 first non-whitespace character; `make' interprets this to mean you
2501 left out the "target: prerequisite" section of a rule. *Note Rule
2504 `No rule to make target `XXX'.'
2505 `No rule to make target `XXX', needed by `YYY'.'
2506 This means that `make' decided it needed to build a target, but
2507 then couldn't find any instructions in the makefile on how to do
2508 that, either explicit or implicit (including in the default rules
2511 If you want that file to be built, you will need to add a rule to
2512 your makefile describing how that target can be built. Other
2513 possible sources of this problem are typos in the makefile (if
2514 that filename is wrong) or a corrupted source tree (if that file
2515 is not supposed to be built, but rather only a prerequisite).
2517 `No targets specified and no makefile found. Stop.'
2519 The former means that you didn't provide any targets to be built
2520 on the command line, and `make' couldn't find any makefiles to
2521 read in. The latter means that some makefile was found, but it
2522 didn't contain any default goal and none was given on the command
2523 line. GNU `make' has nothing to do in these situations. *Note
2524 Arguments to Specify the Makefile: Makefile Arguments.
2526 `Makefile `XXX' was not found.'
2527 `Included makefile `XXX' was not found.'
2528 A makefile specified on the command line (first form) or included
2529 (second form) was not found.
2531 `warning: overriding commands for target `XXX''
2532 `warning: ignoring old commands for target `XXX''
2533 GNU `make' allows commands to be specified only once per target
2534 (except for double-colon rules). If you give commands for a target
2535 which already has been defined to have commands, this warning is
2536 issued and the second set of commands will overwrite the first set.
2537 *Note Multiple Rules for One Target: Multiple Rules.
2539 `Circular XXX <- YYY dependency dropped.'
2540 This means that `make' detected a loop in the dependency graph:
2541 after tracing the prerequisite YYY of target XXX, and its
2542 prerequisites, etc., one of them depended on XXX again.
2544 `Recursive variable `XXX' references itself (eventually). Stop.'
2545 This means you've defined a normal (recursive) `make' variable XXX
2546 that, when it's expanded, will refer to itself (XXX). This is not
2547 allowed; either use simply-expanded variables (`:=') or use the
2548 append operator (`+='). *Note How to Use Variables: Using
2551 `Unterminated variable reference. Stop.'
2552 This means you forgot to provide the proper closing parenthesis or
2553 brace in your variable or function reference.
2555 `insufficient arguments to function `XXX'. Stop.'
2556 This means you haven't provided the requisite number of arguments
2557 for this function. See the documentation of the function for a
2558 description of its arguments. *Note Functions for Transforming
2561 `missing target pattern. Stop.'
2562 `multiple target patterns. Stop.'
2563 `target pattern contains no `%'. Stop.'
2564 `mixed implicit and static pattern rules. Stop.'
2565 These are generated for malformed static pattern rules. The first
2566 means there's no pattern in the target section of the rule; the
2567 second means there are multiple patterns in the target section;
2568 the third means the target doesn't contain a pattern character
2569 (`%'); and the fourth means that all three parts of the static
2570 pattern rule contain pattern characters (`%')-only the first two
2571 parts should. *Note Syntax of Static Pattern Rules: Static Usage.
2573 `warning: -jN forced in submake: disabling jobserver mode.'
2574 This warning and the next are generated if `make' detects error
2575 conditions related to parallel processing on systems where
2576 sub-`make's can communicate (*note Communicating Options to a
2577 Sub-`make': Options/Recursion.). This warning is generated if a
2578 recursive invocation of a `make' process is forced to have `-jN'
2579 in its argument list (where N is greater than one). This could
2580 happen, for example, if you set the `MAKE' environment variable to
2581 `make -j2'. In this case, the sub-`make' doesn't communicate with
2582 other `make' processes and will simply pretend it has two jobs of
2585 `warning: jobserver unavailable: using -j1. Add `+' to parent make rule.'
2586 In order for `make' processes to communicate, the parent will pass
2587 information to the child. Since this could result in problems if
2588 the child process isn't actually a `make', the parent will only do
2589 this if it thinks the child is a `make'. The parent uses the
2590 normal algorithms to determine this (*note How the `MAKE' Variable
2591 Works: MAKE Variable.). If the makefile is constructed such that
2592 the parent doesn't know the child is a `make' process, then the
2593 child will receive only part of the information necessary. In
2594 this case, the child will generate this warning message and
2595 proceed with its build in a sequential manner.
2599 File: make.info, Node: Complex Makefile, Next: GNU Free Documentation License, Prev: Error Messages, Up: Top
2601 Appendix C Complex Makefile Example
2602 ***********************************
2604 Here is the makefile for the GNU `tar' program. This is a moderately
2607 Because it is the first target, the default goal is `all'. An
2608 interesting feature of this makefile is that `testpad.h' is a source
2609 file automatically created by the `testpad' program, itself compiled
2612 If you type `make' or `make all', then `make' creates the `tar'
2613 executable, the `rmt' daemon that provides remote tape access, and the
2614 `tar.info' Info file.
2616 If you type `make install', then `make' not only creates `tar',
2617 `rmt', and `tar.info', but also installs them.
2619 If you type `make clean', then `make' removes the `.o' files, and
2620 the `tar', `rmt', `testpad', `testpad.h', and `core' files.
2622 If you type `make distclean', then `make' not only removes the same
2623 files as does `make clean' but also the `TAGS', `Makefile', and
2624 `config.status' files. (Although it is not evident, this makefile (and
2625 `config.status') is generated by the user with the `configure' program,
2626 which is provided in the `tar' distribution, but is not shown here.)
2628 If you type `make realclean', then `make' removes the same files as
2629 does `make distclean' and also removes the Info files generated from
2632 In addition, there are targets `shar' and `dist' that create
2635 # Generated automatically from Makefile.in by configure.
2636 # Un*x Makefile for GNU tar program.
2637 # Copyright (C) 1991 Free Software Foundation, Inc.
2639 # This program is free software; you can redistribute
2640 # it and/or modify it under the terms of the GNU
2641 # General Public License ...
2647 #### Start of system configuration section. ####
2651 # If you use gcc, you should either run the
2652 # fixincludes script that comes with it or else use
2653 # gcc with the -traditional option. Otherwise ioctl
2654 # calls will be compiled incorrectly on some systems.
2657 INSTALL = /usr/local/bin/install -c
2658 INSTALLDATA = /usr/local/bin/install -c -m 644
2660 # Things you might add to DEFS:
2661 # -DSTDC_HEADERS If you have ANSI C headers and
2663 # -DPOSIX If you have POSIX.1 headers and
2665 # -DBSD42 If you have sys/dir.h (unless
2666 # you use -DPOSIX), sys/file.h,
2667 # and st_blocks in `struct stat'.
2668 # -DUSG If you have System V/ANSI C
2669 # string and memory functions
2670 # and headers, sys/sysmacros.h,
2671 # fcntl.h, getcwd, no valloc,
2672 # and ndir.h (unless
2673 # you use -DDIRENT).
2674 # -DNO_MEMORY_H If USG or STDC_HEADERS but do not
2676 # -DDIRENT If USG and you have dirent.h
2677 # instead of ndir.h.
2678 # -DSIGTYPE=int If your signal handlers
2679 # return int, not void.
2680 # -DNO_MTIO If you lack sys/mtio.h
2682 # -DNO_REMOTE If you do not have a remote shell
2684 # -DUSE_REXEC To use rexec for remote tape
2685 # operations instead of
2686 # forking rsh or remsh.
2687 # -DVPRINTF_MISSING If you lack vprintf function
2688 # (but have _doprnt).
2689 # -DDOPRNT_MISSING If you lack _doprnt function.
2690 # Also need to define
2691 # -DVPRINTF_MISSING.
2692 # -DFTIME_MISSING If you lack ftime system call.
2693 # -DSTRSTR_MISSING If you lack strstr function.
2694 # -DVALLOC_MISSING If you lack valloc function.
2695 # -DMKDIR_MISSING If you lack mkdir and
2696 # rmdir system calls.
2697 # -DRENAME_MISSING If you lack rename system call.
2698 # -DFTRUNCATE_MISSING If you lack ftruncate
2700 # -DV7 On Version 7 Unix (not
2701 # tested in a long time).
2702 # -DEMUL_OPEN3 If you lack a 3-argument version
2703 # of open, and want to emulate it
2704 # with system calls you do have.
2705 # -DNO_OPEN3 If you lack the 3-argument open
2706 # and want to disable the tar -k
2707 # option instead of emulating open.
2708 # -DXENIX If you have sys/inode.h
2709 # and need it 94 to be included.
2711 DEFS = -DSIGTYPE=int -DDIRENT -DSTRSTR_MISSING \
2712 -DVPRINTF_MISSING -DBSD42
2713 # Set this to rtapelib.o unless you defined NO_REMOTE,
2714 # in which case make it empty.
2715 RTAPELIB = rtapelib.o
2717 DEF_AR_FILE = /dev/rmt8
2721 CFLAGS = $(CDEBUG) -I. -I$(srcdir) $(DEFS) \
2722 -DDEF_AR_FILE=\"$(DEF_AR_FILE)\" \
2723 -DDEFBLOCKING=$(DEFBLOCKING)
2727 # Prefix for each installed program,
2728 # normally empty or `g'.
2731 # The directory to install tar in.
2732 bindir = $(prefix)/bin
2734 # The directory to install the info files in.
2735 infodir = $(prefix)/info
2737 #### End of system configuration section. ####
2739 SRC1 = tar.c create.c extract.c buffer.c \
2740 getoldopt.c update.c gnu.c mangle.c
2741 SRC2 = version.c list.c names.c diffarch.c \
2742 port.c wildmat.c getopt.c
2743 SRC3 = getopt1.c regex.c getdate.y
2744 SRCS = $(SRC1) $(SRC2) $(SRC3)
2745 OBJ1 = tar.o create.o extract.o buffer.o \
2746 getoldopt.o update.o gnu.o mangle.o
2747 OBJ2 = version.o list.o names.o diffarch.o \
2748 port.o wildmat.o getopt.o
2749 OBJ3 = getopt1.o regex.o getdate.o $(RTAPELIB)
2750 OBJS = $(OBJ1) $(OBJ2) $(OBJ3)
2751 AUX = README COPYING ChangeLog Makefile.in \
2752 makefile.pc configure configure.in \
2753 tar.texinfo tar.info* texinfo.tex \
2754 tar.h port.h open3.h getopt.h regex.h \
2755 rmt.h rmt.c rtapelib.c alloca.c \
2756 msd_dir.h msd_dir.c tcexparg.c \
2757 level-0 level-1 backup-specs testpad.c
2760 all: tar rmt tar.info
2764 $(CC) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)
2767 $(CC) $(CFLAGS) $(LDFLAGS) -o $@ rmt.c
2769 tar.info: tar.texinfo
2770 makeinfo tar.texinfo
2774 $(INSTALL) tar $(bindir)/$(binprefix)tar
2775 -test ! -f rmt || $(INSTALL) rmt /etc/rmt
2776 $(INSTALLDATA) $(srcdir)/tar.info* $(infodir)
2778 $(OBJS): tar.h port.h testpad.h
2779 regex.o buffer.o tar.o: regex.h
2780 # getdate.y has 8 shift/reduce conflicts.
2786 $(CC) -o $@ testpad.o
2793 rm -f *.o tar rmt testpad testpad.h core
2797 rm -f TAGS Makefile config.status
2800 realclean: distclean
2804 shar: $(SRCS) $(AUX)
2805 shar $(SRCS) $(AUX) | compress \
2806 > tar-`sed -e '/version_string/!d' \
2807 -e 's/[^0-9.]*\([0-9.]*\).*/\1/' \
2812 dist: $(SRCS) $(AUX)
2814 -e '/version_string/!d' \
2815 -e 's/[^0-9.]*\([0-9.]*\).*/\1/' \
2818 -rm -rf `cat .fname`
2820 ln $(SRCS) $(AUX) `cat .fname`
2821 tar chZf `cat .fname`.tar.Z `cat .fname`
2822 -rm -rf `cat .fname` .fname
2824 tar.zoo: $(SRCS) $(AUX)
2828 for X in $(SRCS) $(AUX) ; do \
2830 sed 's/$$/^M/' $$X \
2831 > tmp.dir/$$X ; done
2832 cd tmp.dir ; zoo aM ../tar.zoo *
2836 File: make.info, Node: GNU Free Documentation License, Next: Concept Index, Prev: Complex Makefile, Up: Top
2838 Appendix D GNU Free Documentation License
2839 *****************************************
2841 Version 1.2, November 2002
2843 Copyright (C) 2000,2001,2002 Free Software Foundation, Inc.
2844 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
2846 Everyone is permitted to copy and distribute verbatim copies
2847 of this license document, but changing it is not allowed.
2851 The purpose of this License is to make a manual, textbook, or other
2852 functional and useful document "free" in the sense of freedom: to
2853 assure everyone the effective freedom to copy and redistribute it,
2854 with or without modifying it, either commercially or
2855 noncommercially. Secondarily, this License preserves for the
2856 author and publisher a way to get credit for their work, while not
2857 being considered responsible for modifications made by others.
2859 This License is a kind of "copyleft", which means that derivative
2860 works of the document must themselves be free in the same sense.
2861 It complements the GNU General Public License, which is a copyleft
2862 license designed for free software.
2864 We have designed this License in order to use it for manuals for
2865 free software, because free software needs free documentation: a
2866 free program should come with manuals providing the same freedoms
2867 that the software does. But this License is not limited to
2868 software manuals; it can be used for any textual work, regardless
2869 of subject matter or whether it is published as a printed book.
2870 We recommend this License principally for works whose purpose is
2871 instruction or reference.
2873 1. APPLICABILITY AND DEFINITIONS
2875 This License applies to any manual or other work, in any medium,
2876 that contains a notice placed by the copyright holder saying it
2877 can be distributed under the terms of this License. Such a notice
2878 grants a world-wide, royalty-free license, unlimited in duration,
2879 to use that work under the conditions stated herein. The
2880 "Document", below, refers to any such manual or work. Any member
2881 of the public is a licensee, and is addressed as "you". You
2882 accept the license if you copy, modify or distribute the work in a
2883 way requiring permission under copyright law.
2885 A "Modified Version" of the Document means any work containing the
2886 Document or a portion of it, either copied verbatim, or with
2887 modifications and/or translated into another language.
2889 A "Secondary Section" is a named appendix or a front-matter section
2890 of the Document that deals exclusively with the relationship of the
2891 publishers or authors of the Document to the Document's overall
2892 subject (or to related matters) and contains nothing that could
2893 fall directly within that overall subject. (Thus, if the Document
2894 is in part a textbook of mathematics, a Secondary Section may not
2895 explain any mathematics.) The relationship could be a matter of
2896 historical connection with the subject or with related matters, or
2897 of legal, commercial, philosophical, ethical or political position
2900 The "Invariant Sections" are certain Secondary Sections whose
2901 titles are designated, as being those of Invariant Sections, in
2902 the notice that says that the Document is released under this
2903 License. If a section does not fit the above definition of
2904 Secondary then it is not allowed to be designated as Invariant.
2905 The Document may contain zero Invariant Sections. If the Document
2906 does not identify any Invariant Sections then there are none.
2908 The "Cover Texts" are certain short passages of text that are
2909 listed, as Front-Cover Texts or Back-Cover Texts, in the notice
2910 that says that the Document is released under this License. A
2911 Front-Cover Text may be at most 5 words, and a Back-Cover Text may
2912 be at most 25 words.
2914 A "Transparent" copy of the Document means a machine-readable copy,
2915 represented in a format whose specification is available to the
2916 general public, that is suitable for revising the document
2917 straightforwardly with generic text editors or (for images
2918 composed of pixels) generic paint programs or (for drawings) some
2919 widely available drawing editor, and that is suitable for input to
2920 text formatters or for automatic translation to a variety of
2921 formats suitable for input to text formatters. A copy made in an
2922 otherwise Transparent file format whose markup, or absence of
2923 markup, has been arranged to thwart or discourage subsequent
2924 modification by readers is not Transparent. An image format is
2925 not Transparent if used for any substantial amount of text. A
2926 copy that is not "Transparent" is called "Opaque".
2928 Examples of suitable formats for Transparent copies include plain
2929 ASCII without markup, Texinfo input format, LaTeX input format,
2930 SGML or XML using a publicly available DTD, and
2931 standard-conforming simple HTML, PostScript or PDF designed for
2932 human modification. Examples of transparent image formats include
2933 PNG, XCF and JPG. Opaque formats include proprietary formats that
2934 can be read and edited only by proprietary word processors, SGML or
2935 XML for which the DTD and/or processing tools are not generally
2936 available, and the machine-generated HTML, PostScript or PDF
2937 produced by some word processors for output purposes only.
2939 The "Title Page" means, for a printed book, the title page itself,
2940 plus such following pages as are needed to hold, legibly, the
2941 material this License requires to appear in the title page. For
2942 works in formats which do not have any title page as such, "Title
2943 Page" means the text near the most prominent appearance of the
2944 work's title, preceding the beginning of the body of the text.
2946 A section "Entitled XYZ" means a named subunit of the Document
2947 whose title either is precisely XYZ or contains XYZ in parentheses
2948 following text that translates XYZ in another language. (Here XYZ
2949 stands for a specific section name mentioned below, such as
2950 "Acknowledgements", "Dedications", "Endorsements", or "History".)
2951 To "Preserve the Title" of such a section when you modify the
2952 Document means that it remains a section "Entitled XYZ" according
2955 The Document may include Warranty Disclaimers next to the notice
2956 which states that this License applies to the Document. These
2957 Warranty Disclaimers are considered to be included by reference in
2958 this License, but only as regards disclaiming warranties: any other
2959 implication that these Warranty Disclaimers may have is void and
2960 has no effect on the meaning of this License.
2964 You may copy and distribute the Document in any medium, either
2965 commercially or noncommercially, provided that this License, the
2966 copyright notices, and the license notice saying this License
2967 applies to the Document are reproduced in all copies, and that you
2968 add no other conditions whatsoever to those of this License. You
2969 may not use technical measures to obstruct or control the reading
2970 or further copying of the copies you make or distribute. However,
2971 you may accept compensation in exchange for copies. If you
2972 distribute a large enough number of copies you must also follow
2973 the conditions in section 3.
2975 You may also lend copies, under the same conditions stated above,
2976 and you may publicly display copies.
2978 3. COPYING IN QUANTITY
2980 If you publish printed copies (or copies in media that commonly
2981 have printed covers) of the Document, numbering more than 100, and
2982 the Document's license notice requires Cover Texts, you must
2983 enclose the copies in covers that carry, clearly and legibly, all
2984 these Cover Texts: Front-Cover Texts on the front cover, and
2985 Back-Cover Texts on the back cover. Both covers must also clearly
2986 and legibly identify you as the publisher of these copies. The
2987 front cover must present the full title with all words of the
2988 title equally prominent and visible. You may add other material
2989 on the covers in addition. Copying with changes limited to the
2990 covers, as long as they preserve the title of the Document and
2991 satisfy these conditions, can be treated as verbatim copying in
2994 If the required texts for either cover are too voluminous to fit
2995 legibly, you should put the first ones listed (as many as fit
2996 reasonably) on the actual cover, and continue the rest onto
2999 If you publish or distribute Opaque copies of the Document
3000 numbering more than 100, you must either include a
3001 machine-readable Transparent copy along with each Opaque copy, or
3002 state in or with each Opaque copy a computer-network location from
3003 which the general network-using public has access to download
3004 using public-standard network protocols a complete Transparent
3005 copy of the Document, free of added material. If you use the
3006 latter option, you must take reasonably prudent steps, when you
3007 begin distribution of Opaque copies in quantity, to ensure that
3008 this Transparent copy will remain thus accessible at the stated
3009 location until at least one year after the last time you
3010 distribute an Opaque copy (directly or through your agents or
3011 retailers) of that edition to the public.
3013 It is requested, but not required, that you contact the authors of
3014 the Document well before redistributing any large number of
3015 copies, to give them a chance to provide you with an updated
3016 version of the Document.
3020 You may copy and distribute a Modified Version of the Document
3021 under the conditions of sections 2 and 3 above, provided that you
3022 release the Modified Version under precisely this License, with
3023 the Modified Version filling the role of the Document, thus
3024 licensing distribution and modification of the Modified Version to
3025 whoever possesses a copy of it. In addition, you must do these
3026 things in the Modified Version:
3028 A. Use in the Title Page (and on the covers, if any) a title
3029 distinct from that of the Document, and from those of
3030 previous versions (which should, if there were any, be listed
3031 in the History section of the Document). You may use the
3032 same title as a previous version if the original publisher of
3033 that version gives permission.
3035 B. List on the Title Page, as authors, one or more persons or
3036 entities responsible for authorship of the modifications in
3037 the Modified Version, together with at least five of the
3038 principal authors of the Document (all of its principal
3039 authors, if it has fewer than five), unless they release you
3040 from this requirement.
3042 C. State on the Title page the name of the publisher of the
3043 Modified Version, as the publisher.
3045 D. Preserve all the copyright notices of the Document.
3047 E. Add an appropriate copyright notice for your modifications
3048 adjacent to the other copyright notices.
3050 F. Include, immediately after the copyright notices, a license
3051 notice giving the public permission to use the Modified
3052 Version under the terms of this License, in the form shown in
3055 G. Preserve in that license notice the full lists of Invariant
3056 Sections and required Cover Texts given in the Document's
3059 H. Include an unaltered copy of this License.
3061 I. Preserve the section Entitled "History", Preserve its Title,
3062 and add to it an item stating at least the title, year, new
3063 authors, and publisher of the Modified Version as given on
3064 the Title Page. If there is no section Entitled "History" in
3065 the Document, create one stating the title, year, authors,
3066 and publisher of the Document as given on its Title Page,
3067 then add an item describing the Modified Version as stated in
3068 the previous sentence.
3070 J. Preserve the network location, if any, given in the Document
3071 for public access to a Transparent copy of the Document, and
3072 likewise the network locations given in the Document for
3073 previous versions it was based on. These may be placed in
3074 the "History" section. You may omit a network location for a
3075 work that was published at least four years before the
3076 Document itself, or if the original publisher of the version
3077 it refers to gives permission.
3079 K. For any section Entitled "Acknowledgements" or "Dedications",
3080 Preserve the Title of the section, and preserve in the
3081 section all the substance and tone of each of the contributor
3082 acknowledgements and/or dedications given therein.
3084 L. Preserve all the Invariant Sections of the Document,
3085 unaltered in their text and in their titles. Section numbers
3086 or the equivalent are not considered part of the section
3089 M. Delete any section Entitled "Endorsements". Such a section
3090 may not be included in the Modified Version.
3092 N. Do not retitle any existing section to be Entitled
3093 "Endorsements" or to conflict in title with any Invariant
3096 O. Preserve any Warranty Disclaimers.
3098 If the Modified Version includes new front-matter sections or
3099 appendices that qualify as Secondary Sections and contain no
3100 material copied from the Document, you may at your option
3101 designate some or all of these sections as invariant. To do this,
3102 add their titles to the list of Invariant Sections in the Modified
3103 Version's license notice. These titles must be distinct from any
3104 other section titles.
3106 You may add a section Entitled "Endorsements", provided it contains
3107 nothing but endorsements of your Modified Version by various
3108 parties--for example, statements of peer review or that the text
3109 has been approved by an organization as the authoritative
3110 definition of a standard.
3112 You may add a passage of up to five words as a Front-Cover Text,
3113 and a passage of up to 25 words as a Back-Cover Text, to the end
3114 of the list of Cover Texts in the Modified Version. Only one
3115 passage of Front-Cover Text and one of Back-Cover Text may be
3116 added by (or through arrangements made by) any one entity. If the
3117 Document already includes a cover text for the same cover,
3118 previously added by you or by arrangement made by the same entity
3119 you are acting on behalf of, you may not add another; but you may
3120 replace the old one, on explicit permission from the previous
3121 publisher that added the old one.
3123 The author(s) and publisher(s) of the Document do not by this
3124 License give permission to use their names for publicity for or to
3125 assert or imply endorsement of any Modified Version.
3127 5. COMBINING DOCUMENTS
3129 You may combine the Document with other documents released under
3130 this License, under the terms defined in section 4 above for
3131 modified versions, provided that you include in the combination
3132 all of the Invariant Sections of all of the original documents,
3133 unmodified, and list them all as Invariant Sections of your
3134 combined work in its license notice, and that you preserve all
3135 their Warranty Disclaimers.
3137 The combined work need only contain one copy of this License, and
3138 multiple identical Invariant Sections may be replaced with a single
3139 copy. If there are multiple Invariant Sections with the same name
3140 but different contents, make the title of each such section unique
3141 by adding at the end of it, in parentheses, the name of the
3142 original author or publisher of that section if known, or else a
3143 unique number. Make the same adjustment to the section titles in
3144 the list of Invariant Sections in the license notice of the
3147 In the combination, you must combine any sections Entitled
3148 "History" in the various original documents, forming one section
3149 Entitled "History"; likewise combine any sections Entitled
3150 "Acknowledgements", and any sections Entitled "Dedications". You
3151 must delete all sections Entitled "Endorsements."
3153 6. COLLECTIONS OF DOCUMENTS
3155 You may make a collection consisting of the Document and other
3156 documents released under this License, and replace the individual
3157 copies of this License in the various documents with a single copy
3158 that is included in the collection, provided that you follow the
3159 rules of this License for verbatim copying of each of the
3160 documents in all other respects.
3162 You may extract a single document from such a collection, and
3163 distribute it individually under this License, provided you insert
3164 a copy of this License into the extracted document, and follow
3165 this License in all other respects regarding verbatim copying of
3168 7. AGGREGATION WITH INDEPENDENT WORKS
3170 A compilation of the Document or its derivatives with other
3171 separate and independent documents or works, in or on a volume of
3172 a storage or distribution medium, is called an "aggregate" if the
3173 copyright resulting from the compilation is not used to limit the
3174 legal rights of the compilation's users beyond what the individual
3175 works permit. When the Document is included in an aggregate, this
3176 License does not apply to the other works in the aggregate which
3177 are not themselves derivative works of the Document.
3179 If the Cover Text requirement of section 3 is applicable to these
3180 copies of the Document, then if the Document is less than one half
3181 of the entire aggregate, the Document's Cover Texts may be placed
3182 on covers that bracket the Document within the aggregate, or the
3183 electronic equivalent of covers if the Document is in electronic
3184 form. Otherwise they must appear on printed covers that bracket
3185 the whole aggregate.
3189 Translation is considered a kind of modification, so you may
3190 distribute translations of the Document under the terms of section
3191 4. Replacing Invariant Sections with translations requires special
3192 permission from their copyright holders, but you may include
3193 translations of some or all Invariant Sections in addition to the
3194 original versions of these Invariant Sections. You may include a
3195 translation of this License, and all the license notices in the
3196 Document, and any Warranty Disclaimers, provided that you also
3197 include the original English version of this License and the
3198 original versions of those notices and disclaimers. In case of a
3199 disagreement between the translation and the original version of
3200 this License or a notice or disclaimer, the original version will
3203 If a section in the Document is Entitled "Acknowledgements",
3204 "Dedications", or "History", the requirement (section 4) to
3205 Preserve its Title (section 1) will typically require changing the
3210 You may not copy, modify, sublicense, or distribute the Document
3211 except as expressly provided for under this License. Any other
3212 attempt to copy, modify, sublicense or distribute the Document is
3213 void, and will automatically terminate your rights under this
3214 License. However, parties who have received copies, or rights,
3215 from you under this License will not have their licenses
3216 terminated so long as such parties remain in full compliance.
3218 10. FUTURE REVISIONS OF THIS LICENSE
3220 The Free Software Foundation may publish new, revised versions of
3221 the GNU Free Documentation License from time to time. Such new
3222 versions will be similar in spirit to the present version, but may
3223 differ in detail to address new problems or concerns. See
3224 `http://www.gnu.org/copyleft/'.
3226 Each version of the License is given a distinguishing version
3227 number. If the Document specifies that a particular numbered
3228 version of this License "or any later version" applies to it, you
3229 have the option of following the terms and conditions either of
3230 that specified version or of any later version that has been
3231 published (not as a draft) by the Free Software Foundation. If
3232 the Document does not specify a version number of this License,
3233 you may choose any version ever published (not as a draft) by the
3234 Free Software Foundation.
3236 D.1 ADDENDUM: How to use this License for your documents
3237 ========================================================
3239 To use this License in a document you have written, include a copy of
3240 the License in the document and put the following copyright and license
3241 notices just after the title page:
3243 Copyright (C) YEAR YOUR NAME.
3244 Permission is granted to copy, distribute and/or modify this document
3245 under the terms of the GNU Free Documentation License, Version 1.2
3246 or any later version published by the Free Software Foundation;
3247 with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
3248 Texts. A copy of the license is included in the section entitled ``GNU
3249 Free Documentation License''.
3251 If you have Invariant Sections, Front-Cover Texts and Back-Cover
3252 Texts, replace the "with...Texts." line with this:
3254 with the Invariant Sections being LIST THEIR TITLES, with
3255 the Front-Cover Texts being LIST, and with the Back-Cover Texts
3258 If you have Invariant Sections without Cover Texts, or some other
3259 combination of the three, merge those two alternatives to suit the
3262 If your document contains nontrivial examples of program code, we
3263 recommend releasing these examples in parallel under your choice of
3264 free software license, such as the GNU General Public License, to
3265 permit their use in free software.
3268 File: make.info, Node: Concept Index, Next: Name Index, Prev: GNU Free Documentation License, Up: Top
3276 * # (comments), in commands: Command Syntax. (line 27)
3277 * # (comments), in makefile: Makefile Contents. (line 41)
3278 * #include: Automatic Prerequisites.
3280 * $, in function call: Syntax of Functions. (line 6)
3281 * $, in rules: Rule Syntax. (line 32)
3282 * $, in variable name: Computed Names. (line 6)
3283 * $, in variable reference: Reference. (line 6)
3284 * %, in pattern rules: Pattern Intro. (line 9)
3285 * %, quoting in patsubst: Text Functions. (line 26)
3286 * %, quoting in static pattern: Static Usage. (line 37)
3287 * %, quoting in vpath: Selective Search. (line 38)
3288 * %, quoting with \ (backslash) <1>: Text Functions. (line 26)
3289 * %, quoting with \ (backslash) <2>: Static Usage. (line 37)
3290 * %, quoting with \ (backslash): Selective Search. (line 38)
3291 * * (wildcard character): Wildcards. (line 6)
3292 * +, and command execution: Instead of Execution.
3294 * +, and commands: MAKE Variable. (line 18)
3295 * +, and define: Sequences. (line 50)
3296 * +=: Appending. (line 6)
3297 * +=, expansion: Reading Makefiles. (line 33)
3298 * ,v (RCS file extension): Catalogue of Rules. (line 164)
3299 * - (in commands): Errors. (line 19)
3300 * -, and define: Sequences. (line 50)
3301 * --always-make: Options Summary. (line 15)
3302 * --assume-new <1>: Options Summary. (line 242)
3303 * --assume-new: Instead of Execution.
3305 * --assume-new, and recursion: Options/Recursion. (line 22)
3306 * --assume-old <1>: Options Summary. (line 147)
3307 * --assume-old: Avoiding Compilation.
3309 * --assume-old, and recursion: Options/Recursion. (line 22)
3310 * --check-symlink-times: Options Summary. (line 130)
3311 * --debug: Options Summary. (line 42)
3312 * --directory <1>: Options Summary. (line 26)
3313 * --directory: Recursion. (line 20)
3314 * --directory, and --print-directory: -w Option. (line 20)
3315 * --directory, and recursion: Options/Recursion. (line 22)
3316 * --dry-run <1>: Options Summary. (line 140)
3317 * --dry-run <2>: Instead of Execution.
3319 * --dry-run: Echoing. (line 18)
3320 * --environment-overrides: Options Summary. (line 78)
3321 * --file <1>: Options Summary. (line 84)
3322 * --file <2>: Makefile Arguments. (line 6)
3323 * --file: Makefile Names. (line 23)
3324 * --file, and recursion: Options/Recursion. (line 22)
3325 * --help: Options Summary. (line 90)
3326 * --ignore-errors <1>: Options Summary. (line 94)
3327 * --ignore-errors: Errors. (line 30)
3328 * --include-dir <1>: Options Summary. (line 99)
3329 * --include-dir: Include. (line 52)
3330 * --jobs <1>: Options Summary. (line 106)
3331 * --jobs: Parallel. (line 6)
3332 * --jobs, and recursion: Options/Recursion. (line 25)
3333 * --just-print <1>: Options Summary. (line 139)
3334 * --just-print <2>: Instead of Execution.
3336 * --just-print: Echoing. (line 18)
3337 * --keep-going <1>: Options Summary. (line 115)
3338 * --keep-going <2>: Testing. (line 16)
3339 * --keep-going: Errors. (line 47)
3340 * --load-average <1>: Options Summary. (line 122)
3341 * --load-average: Parallel. (line 57)
3342 * --makefile <1>: Options Summary. (line 85)
3343 * --makefile <2>: Makefile Arguments. (line 6)
3344 * --makefile: Makefile Names. (line 23)
3345 * --max-load <1>: Options Summary. (line 123)
3346 * --max-load: Parallel. (line 57)
3347 * --new-file <1>: Options Summary. (line 241)
3348 * --new-file: Instead of Execution.
3350 * --new-file, and recursion: Options/Recursion. (line 22)
3351 * --no-builtin-rules: Options Summary. (line 175)
3352 * --no-builtin-variables: Options Summary. (line 188)
3353 * --no-keep-going: Options Summary. (line 203)
3354 * --no-print-directory <1>: Options Summary. (line 233)
3355 * --no-print-directory: -w Option. (line 20)
3356 * --old-file <1>: Options Summary. (line 146)
3357 * --old-file: Avoiding Compilation.
3359 * --old-file, and recursion: Options/Recursion. (line 22)
3360 * --print-data-base: Options Summary. (line 155)
3361 * --print-directory: Options Summary. (line 225)
3362 * --print-directory, and --directory: -w Option. (line 20)
3363 * --print-directory, and recursion: -w Option. (line 20)
3364 * --print-directory, disabling: -w Option. (line 20)
3365 * --question <1>: Options Summary. (line 167)
3366 * --question: Instead of Execution.
3368 * --quiet <1>: Options Summary. (line 198)
3369 * --quiet: Echoing. (line 24)
3370 * --recon <1>: Options Summary. (line 141)
3371 * --recon <2>: Instead of Execution.
3373 * --recon: Echoing. (line 18)
3374 * --silent <1>: Options Summary. (line 197)
3375 * --silent: Echoing. (line 24)
3376 * --stop: Options Summary. (line 204)
3377 * --touch <1>: Options Summary. (line 212)
3378 * --touch: Instead of Execution.
3380 * --touch, and recursion: MAKE Variable. (line 34)
3381 * --version: Options Summary. (line 220)
3382 * --warn-undefined-variables: Options Summary. (line 251)
3383 * --what-if <1>: Options Summary. (line 240)
3384 * --what-if: Instead of Execution.
3386 * -B: Options Summary. (line 14)
3387 * -b: Options Summary. (line 9)
3388 * -C <1>: Options Summary. (line 25)
3389 * -C: Recursion. (line 20)
3390 * -C, and -w: -w Option. (line 20)
3391 * -C, and recursion: Options/Recursion. (line 22)
3392 * -d: Options Summary. (line 33)
3393 * -e: Options Summary. (line 77)
3394 * -e (shell flag): Automatic Prerequisites.
3396 * -f <1>: Options Summary. (line 83)
3397 * -f <2>: Makefile Arguments. (line 6)
3398 * -f: Makefile Names. (line 23)
3399 * -f, and recursion: Options/Recursion. (line 22)
3400 * -h: Options Summary. (line 89)
3401 * -I: Options Summary. (line 98)
3402 * -i <1>: Options Summary. (line 93)
3403 * -i: Errors. (line 30)
3404 * -I: Include. (line 52)
3405 * -j <1>: Options Summary. (line 105)
3406 * -j: Parallel. (line 6)
3407 * -j, and archive update: Archive Pitfalls. (line 6)
3408 * -j, and recursion: Options/Recursion. (line 25)
3409 * -k <1>: Options Summary. (line 114)
3410 * -k <2>: Testing. (line 16)
3411 * -k: Errors. (line 47)
3412 * -L: Options Summary. (line 129)
3413 * -l: Options Summary. (line 121)
3414 * -l (library search): Libraries/Search. (line 6)
3415 * -l (load average): Parallel. (line 57)
3416 * -m: Options Summary. (line 10)
3417 * -M (to compiler): Automatic Prerequisites.
3419 * -MM (to GNU compiler): Automatic Prerequisites.
3421 * -n <1>: Options Summary. (line 138)
3422 * -n <2>: Instead of Execution.
3424 * -n: Echoing. (line 18)
3425 * -o <1>: Options Summary. (line 145)
3426 * -o: Avoiding Compilation.
3428 * -o, and recursion: Options/Recursion. (line 22)
3429 * -p: Options Summary. (line 154)
3430 * -q <1>: Options Summary. (line 166)
3431 * -q: Instead of Execution.
3433 * -R: Options Summary. (line 187)
3434 * -r: Options Summary. (line 174)
3435 * -S: Options Summary. (line 202)
3436 * -s <1>: Options Summary. (line 196)
3437 * -s: Echoing. (line 24)
3438 * -t <1>: Options Summary. (line 211)
3439 * -t: Instead of Execution.
3441 * -t, and recursion: MAKE Variable. (line 34)
3442 * -v: Options Summary. (line 219)
3443 * -W: Options Summary. (line 239)
3444 * -w: Options Summary. (line 224)
3445 * -W: Instead of Execution.
3447 * -w, and -C: -w Option. (line 20)
3448 * -w, and recursion: -w Option. (line 20)
3449 * -W, and recursion: Options/Recursion. (line 22)
3450 * -w, disabling: -w Option. (line 20)
3451 * .a (archives): Archive Suffix Rules.
3453 * .C: Catalogue of Rules. (line 39)
3454 * .c: Catalogue of Rules. (line 35)
3455 * .cc: Catalogue of Rules. (line 39)
3456 * .ch: Catalogue of Rules. (line 151)
3457 * .cpp: Catalogue of Rules. (line 39)
3458 * .d: Automatic Prerequisites.
3460 * .def: Catalogue of Rules. (line 74)
3461 * .dvi: Catalogue of Rules. (line 151)
3462 * .F: Catalogue of Rules. (line 49)
3463 * .f: Catalogue of Rules. (line 49)
3464 * .info: Catalogue of Rules. (line 158)
3465 * .l: Catalogue of Rules. (line 124)
3466 * .LIBPATTERNS, and link libraries: Libraries/Search. (line 6)
3467 * .ln: Catalogue of Rules. (line 146)
3468 * .mod: Catalogue of Rules. (line 74)
3469 * .o: Catalogue of Rules. (line 35)
3470 * .p: Catalogue of Rules. (line 45)
3471 * .PRECIOUS intermediate files: Chained Rules. (line 56)
3472 * .r: Catalogue of Rules. (line 49)
3473 * .S: Catalogue of Rules. (line 82)
3474 * .s: Catalogue of Rules. (line 79)
3475 * .sh: Catalogue of Rules. (line 180)
3476 * .sym: Catalogue of Rules. (line 74)
3477 * .tex: Catalogue of Rules. (line 151)
3478 * .texi: Catalogue of Rules. (line 158)
3479 * .texinfo: Catalogue of Rules. (line 158)
3480 * .txinfo: Catalogue of Rules. (line 158)
3481 * .w: Catalogue of Rules. (line 151)
3482 * .web: Catalogue of Rules. (line 151)
3483 * .y: Catalogue of Rules. (line 120)
3484 * :: rules (double-colon): Double-Colon. (line 6)
3485 * := <1>: Setting. (line 6)
3486 * :=: Flavors. (line 56)
3487 * = <1>: Setting. (line 6)
3488 * =: Flavors. (line 10)
3489 * =, expansion: Reading Makefiles. (line 33)
3490 * ? (wildcard character): Wildcards. (line 6)
3491 * ?= <1>: Setting. (line 6)
3492 * ?=: Flavors. (line 129)
3493 * ?=, expansion: Reading Makefiles. (line 33)
3494 * @ (in commands): Echoing. (line 6)
3495 * @, and define: Sequences. (line 50)
3496 * [...] (wildcard characters): Wildcards. (line 6)
3497 * \ (backslash), for continuation lines: Simple Makefile. (line 40)
3498 * \ (backslash), in commands: Splitting Lines. (line 6)
3499 * \ (backslash), to quote % <1>: Text Functions. (line 26)
3500 * \ (backslash), to quote % <2>: Static Usage. (line 37)
3501 * \ (backslash), to quote %: Selective Search. (line 38)
3502 * __.SYMDEF: Archive Symbols. (line 6)
3503 * abspath: File Name Functions. (line 121)
3504 * algorithm for directory search: Search Algorithm. (line 6)
3505 * all (standard target): Goals. (line 72)
3506 * appending to variables: Appending. (line 6)
3507 * ar: Implicit Variables. (line 41)
3508 * archive: Archives. (line 6)
3509 * archive member targets: Archive Members. (line 6)
3510 * archive symbol directory updating: Archive Symbols. (line 6)
3511 * archive, and -j: Archive Pitfalls. (line 6)
3512 * archive, and parallel execution: Archive Pitfalls. (line 6)
3513 * archive, suffix rule for: Archive Suffix Rules.
3515 * Arg list too long: Options/Recursion. (line 57)
3516 * arguments of functions: Syntax of Functions. (line 6)
3517 * as <1>: Implicit Variables. (line 44)
3518 * as: Catalogue of Rules. (line 79)
3519 * assembly, rule to compile: Catalogue of Rules. (line 79)
3520 * automatic generation of prerequisites <1>: Automatic Prerequisites.
3522 * automatic generation of prerequisites: Include. (line 50)
3523 * automatic variables: Automatic Variables. (line 6)
3524 * automatic variables in prerequisites: Automatic Variables. (line 17)
3525 * backquotes: Shell Function. (line 6)
3526 * backslash (\), for continuation lines: Simple Makefile. (line 40)
3527 * backslash (\), in commands: Splitting Lines. (line 6)
3528 * backslash (\), to quote % <1>: Text Functions. (line 26)
3529 * backslash (\), to quote % <2>: Static Usage. (line 37)
3530 * backslash (\), to quote %: Selective Search. (line 38)
3531 * backslashes in pathnames and wildcard expansion: Wildcard Pitfall.
3533 * basename: File Name Functions. (line 57)
3534 * binary packages: Install Command Categories.
3536 * broken pipe: Parallel. (line 30)
3537 * bugs, reporting: Bugs. (line 6)
3538 * built-in special targets: Special Targets. (line 6)
3539 * C++, rule to compile: Catalogue of Rules. (line 39)
3540 * C, rule to compile: Catalogue of Rules. (line 35)
3541 * cc <1>: Implicit Variables. (line 47)
3542 * cc: Catalogue of Rules. (line 35)
3543 * cd (shell command) <1>: MAKE Variable. (line 16)
3544 * cd (shell command): Execution. (line 10)
3545 * chains of rules: Chained Rules. (line 6)
3546 * check (standard target): Goals. (line 114)
3547 * clean (standard target): Goals. (line 75)
3548 * clean target <1>: Cleanup. (line 11)
3549 * clean target: Simple Makefile. (line 83)
3550 * cleaning up: Cleanup. (line 6)
3551 * clobber (standard target): Goals. (line 86)
3552 * co <1>: Implicit Variables. (line 56)
3553 * co: Catalogue of Rules. (line 164)
3554 * combining rules by prerequisite: Combine By Prerequisite.
3556 * command line variable definitions, and recursion: Options/Recursion.
3558 * command line variables: Overriding. (line 6)
3559 * command syntax: Command Syntax. (line 6)
3560 * commands: Rule Syntax. (line 26)
3561 * commands setting shell variables: Execution. (line 10)
3562 * commands, backslash (\) in: Splitting Lines. (line 6)
3563 * commands, comments in: Command Syntax. (line 27)
3564 * commands, echoing: Echoing. (line 6)
3565 * commands, empty: Empty Commands. (line 6)
3566 * commands, errors in: Errors. (line 6)
3567 * commands, execution: Execution. (line 6)
3568 * commands, execution in parallel: Parallel. (line 6)
3569 * commands, expansion: Shell Function. (line 6)
3570 * commands, how to write: Commands. (line 6)
3571 * commands, instead of executing: Instead of Execution.
3573 * commands, introduction to: Rule Introduction. (line 8)
3574 * commands, quoting newlines in: Splitting Lines. (line 6)
3575 * commands, sequences of: Sequences. (line 6)
3576 * commands, splitting: Splitting Lines. (line 6)
3577 * commands, using variables in: Variables in Commands.
3579 * comments, in commands: Command Syntax. (line 27)
3580 * comments, in makefile: Makefile Contents. (line 41)
3581 * compatibility: Features. (line 6)
3582 * compatibility in exporting: Variables/Recursion. (line 105)
3583 * compilation, testing: Testing. (line 6)
3584 * computed variable name: Computed Names. (line 6)
3585 * conditional expansion: Conditional Functions.
3587 * conditional variable assignment: Flavors. (line 129)
3588 * conditionals: Conditionals. (line 6)
3589 * continuation lines: Simple Makefile. (line 40)
3590 * controlling make: Make Control Functions.
3592 * conventions for makefiles: Makefile Conventions.
3594 * ctangle <1>: Implicit Variables. (line 107)
3595 * ctangle: Catalogue of Rules. (line 151)
3596 * cweave <1>: Implicit Variables. (line 101)
3597 * cweave: Catalogue of Rules. (line 151)
3598 * data base of make rules: Options Summary. (line 155)
3599 * deducing commands (implicit rules): make Deduces. (line 6)
3600 * default directories for included makefiles: Include. (line 52)
3601 * default goal <1>: Rules. (line 11)
3602 * default goal: How Make Works. (line 11)
3603 * default makefile name: Makefile Names. (line 6)
3604 * default rules, last-resort: Last Resort. (line 6)
3605 * define, expansion: Reading Makefiles. (line 33)
3606 * defining variables verbatim: Defining. (line 6)
3607 * deletion of target files <1>: Interrupts. (line 6)
3608 * deletion of target files: Errors. (line 64)
3609 * directive: Makefile Contents. (line 28)
3610 * directories, printing them: -w Option. (line 6)
3611 * directories, updating archive symbol: Archive Symbols. (line 6)
3612 * directory part: File Name Functions. (line 17)
3613 * directory search (VPATH): Directory Search. (line 6)
3614 * directory search (VPATH), and implicit rules: Implicit/Search.
3616 * directory search (VPATH), and link libraries: Libraries/Search.
3618 * directory search (VPATH), and shell commands: Commands/Search.
3620 * directory search algorithm: Search Algorithm. (line 6)
3621 * directory search, traditional (GPATH): Search Algorithm. (line 42)
3622 * dist (standard target): Goals. (line 106)
3623 * distclean (standard target): Goals. (line 84)
3624 * dollar sign ($), in function call: Syntax of Functions. (line 6)
3625 * dollar sign ($), in rules: Rule Syntax. (line 32)
3626 * dollar sign ($), in variable name: Computed Names. (line 6)
3627 * dollar sign ($), in variable reference: Reference. (line 6)
3628 * DOS, choosing a shell in: Choosing the Shell. (line 36)
3629 * double-colon rules: Double-Colon. (line 6)
3630 * duplicate words, removing: Text Functions. (line 155)
3631 * E2BIG: Options/Recursion. (line 57)
3632 * echoing of commands: Echoing. (line 6)
3633 * editor: Introduction. (line 22)
3634 * Emacs (M-x compile): Errors. (line 62)
3635 * empty commands: Empty Commands. (line 6)
3636 * empty targets: Empty Targets. (line 6)
3637 * environment: Environment. (line 6)
3638 * environment, and recursion: Variables/Recursion. (line 6)
3639 * environment, SHELL in: Choosing the Shell. (line 10)
3640 * error, stopping on: Make Control Functions.
3642 * errors (in commands): Errors. (line 6)
3643 * errors with wildcards: Wildcard Pitfall. (line 6)
3644 * evaluating makefile syntax: Eval Function. (line 6)
3645 * execution, in parallel: Parallel. (line 6)
3646 * execution, instead of: Instead of Execution.
3648 * execution, of commands: Execution. (line 6)
3649 * exit status (errors): Errors. (line 6)
3650 * exit status of make: Running. (line 18)
3651 * expansion, secondary: Secondary Expansion. (line 6)
3652 * explicit rule, definition of: Makefile Contents. (line 10)
3653 * explicit rule, expansion: Reading Makefiles. (line 62)
3654 * explicit rules, secondary expansion of: Secondary Expansion.
3656 * exporting variables: Variables/Recursion. (line 6)
3657 * f77 <1>: Implicit Variables. (line 64)
3658 * f77: Catalogue of Rules. (line 49)
3659 * FDL, GNU Free Documentation License: GNU Free Documentation License.
3661 * features of GNU make: Features. (line 6)
3662 * features, missing: Missing. (line 6)
3663 * file name functions: File Name Functions. (line 6)
3664 * file name of makefile: Makefile Names. (line 6)
3665 * file name of makefile, how to specify: Makefile Names. (line 30)
3666 * file name prefix, adding: File Name Functions. (line 79)
3667 * file name suffix: File Name Functions. (line 43)
3668 * file name suffix, adding: File Name Functions. (line 68)
3669 * file name with wildcards: Wildcards. (line 6)
3670 * file name, abspath of: File Name Functions. (line 121)
3671 * file name, basename of: File Name Functions. (line 57)
3672 * file name, directory part: File Name Functions. (line 17)
3673 * file name, nondirectory part: File Name Functions. (line 27)
3674 * file name, realpath of: File Name Functions. (line 114)
3675 * files, assuming new: Instead of Execution.
3677 * files, assuming old: Avoiding Compilation.
3679 * files, avoiding recompilation of: Avoiding Compilation.
3681 * files, intermediate: Chained Rules. (line 16)
3682 * filtering out words: Text Functions. (line 132)
3683 * filtering words: Text Functions. (line 114)
3684 * finding strings: Text Functions. (line 103)
3685 * flags: Options Summary. (line 6)
3686 * flags for compilers: Implicit Variables. (line 6)
3687 * flavor of variable: Flavor Function. (line 6)
3688 * flavors of variables: Flavors. (line 6)
3689 * FORCE: Force Targets. (line 6)
3690 * force targets: Force Targets. (line 6)
3691 * Fortran, rule to compile: Catalogue of Rules. (line 49)
3692 * functions: Functions. (line 6)
3693 * functions, for controlling make: Make Control Functions.
3695 * functions, for file names: File Name Functions. (line 6)
3696 * functions, for text: Text Functions. (line 6)
3697 * functions, syntax of: Syntax of Functions. (line 6)
3698 * functions, user defined: Call Function. (line 6)
3699 * g++ <1>: Implicit Variables. (line 53)
3700 * g++: Catalogue of Rules. (line 39)
3701 * gcc: Catalogue of Rules. (line 35)
3702 * generating prerequisites automatically <1>: Automatic Prerequisites.
3704 * generating prerequisites automatically: Include. (line 50)
3705 * get <1>: Implicit Variables. (line 67)
3706 * get: Catalogue of Rules. (line 173)
3707 * globbing (wildcards): Wildcards. (line 6)
3708 * goal: How Make Works. (line 11)
3709 * goal, default <1>: Rules. (line 11)
3710 * goal, default: How Make Works. (line 11)
3711 * goal, how to specify: Goals. (line 6)
3712 * home directory: Wildcards. (line 11)
3713 * IEEE Standard 1003.2: Overview. (line 13)
3714 * ifdef, expansion: Reading Makefiles. (line 51)
3715 * ifeq, expansion: Reading Makefiles. (line 51)
3716 * ifndef, expansion: Reading Makefiles. (line 51)
3717 * ifneq, expansion: Reading Makefiles. (line 51)
3718 * implicit rule: Implicit Rules. (line 6)
3719 * implicit rule, and directory search: Implicit/Search. (line 6)
3720 * implicit rule, and VPATH: Implicit/Search. (line 6)
3721 * implicit rule, definition of: Makefile Contents. (line 16)
3722 * implicit rule, expansion: Reading Makefiles. (line 62)
3723 * implicit rule, how to use: Using Implicit. (line 6)
3724 * implicit rule, introduction to: make Deduces. (line 6)
3725 * implicit rule, predefined: Catalogue of Rules. (line 6)
3726 * implicit rule, search algorithm: Implicit Rule Search.
3728 * implicit rules, secondary expansion of: Secondary Expansion.
3730 * included makefiles, default directories: Include. (line 52)
3731 * including (MAKEFILE_LIST variable): MAKEFILE_LIST Variable.
3733 * including (MAKEFILES variable): MAKEFILES Variable. (line 6)
3734 * including other makefiles: Include. (line 6)
3735 * incompatibilities: Missing. (line 6)
3736 * Info, rule to format: Catalogue of Rules. (line 158)
3737 * install (standard target): Goals. (line 92)
3738 * intermediate files: Chained Rules. (line 16)
3739 * intermediate files, preserving: Chained Rules. (line 46)
3740 * intermediate targets, explicit: Special Targets. (line 44)
3741 * interrupt: Interrupts. (line 6)
3742 * job slots: Parallel. (line 6)
3743 * job slots, and recursion: Options/Recursion. (line 25)
3744 * jobs, limiting based on load: Parallel. (line 57)
3745 * joining lists of words: File Name Functions. (line 90)
3746 * killing (interruption): Interrupts. (line 6)
3747 * last-resort default rules: Last Resort. (line 6)
3748 * ld: Catalogue of Rules. (line 86)
3749 * lex <1>: Implicit Variables. (line 71)
3750 * lex: Catalogue of Rules. (line 124)
3751 * Lex, rule to run: Catalogue of Rules. (line 124)
3752 * libraries for linking, directory search: Libraries/Search. (line 6)
3753 * library archive, suffix rule for: Archive Suffix Rules.
3755 * limiting jobs based on load: Parallel. (line 57)
3756 * link libraries, and directory search: Libraries/Search. (line 6)
3757 * link libraries, patterns matching: Libraries/Search. (line 6)
3758 * linking, predefined rule for: Catalogue of Rules. (line 86)
3759 * lint <1>: Implicit Variables. (line 78)
3760 * lint: Catalogue of Rules. (line 146)
3761 * lint, rule to run: Catalogue of Rules. (line 146)
3762 * list of all prerequisites: Automatic Variables. (line 61)
3763 * list of changed prerequisites: Automatic Variables. (line 51)
3764 * load average: Parallel. (line 57)
3765 * loops in variable expansion: Flavors. (line 44)
3766 * lpr (shell command) <1>: Empty Targets. (line 25)
3767 * lpr (shell command): Wildcard Examples. (line 21)
3768 * m2c <1>: Implicit Variables. (line 81)
3769 * m2c: Catalogue of Rules. (line 74)
3770 * macro: Using Variables. (line 10)
3771 * make depend: Automatic Prerequisites.
3773 * makefile: Introduction. (line 7)
3774 * makefile name: Makefile Names. (line 6)
3775 * makefile name, how to specify: Makefile Names. (line 30)
3776 * makefile rule parts: Rule Introduction. (line 6)
3777 * makefile syntax, evaluating: Eval Function. (line 6)
3778 * makefile, and MAKEFILES variable: MAKEFILES Variable. (line 6)
3779 * makefile, conventions for: Makefile Conventions.
3781 * makefile, how make processes: How Make Works. (line 6)
3782 * makefile, how to write: Makefiles. (line 6)
3783 * makefile, including: Include. (line 6)
3784 * makefile, overriding: Overriding Makefiles.
3786 * makefile, parsing: Reading Makefiles. (line 6)
3787 * makefile, remaking of: Remaking Makefiles. (line 6)
3788 * makefile, simple: Simple Makefile. (line 6)
3789 * makefiles, and MAKEFILE_LIST variable: MAKEFILE_LIST Variable.
3791 * makefiles, and special variables: Special Variables. (line 6)
3792 * makeinfo <1>: Implicit Variables. (line 88)
3793 * makeinfo: Catalogue of Rules. (line 158)
3794 * match-anything rule: Match-Anything Rules.
3796 * match-anything rule, used to override: Overriding Makefiles.
3798 * missing features: Missing. (line 6)
3799 * mistakes with wildcards: Wildcard Pitfall. (line 6)
3800 * modified variable reference: Substitution Refs. (line 6)
3801 * Modula-2, rule to compile: Catalogue of Rules. (line 74)
3802 * mostlyclean (standard target): Goals. (line 78)
3803 * multiple rules for one target: Multiple Rules. (line 6)
3804 * multiple rules for one target (::): Double-Colon. (line 6)
3805 * multiple targets: Multiple Targets. (line 6)
3806 * multiple targets, in pattern rule: Pattern Intro. (line 49)
3807 * name of makefile: Makefile Names. (line 6)
3808 * name of makefile, how to specify: Makefile Names. (line 30)
3809 * nested variable reference: Computed Names. (line 6)
3810 * newline, quoting, in commands: Splitting Lines. (line 6)
3811 * newline, quoting, in makefile: Simple Makefile. (line 40)
3812 * nondirectory part: File Name Functions. (line 27)
3813 * normal prerequisites: Prerequisite Types. (line 6)
3814 * OBJ: Variables Simplify. (line 20)
3815 * obj: Variables Simplify. (line 20)
3816 * OBJECTS: Variables Simplify. (line 20)
3817 * objects: Variables Simplify. (line 14)
3818 * OBJS: Variables Simplify. (line 20)
3819 * objs: Variables Simplify. (line 20)
3820 * old-fashioned suffix rules: Suffix Rules. (line 6)
3821 * options: Options Summary. (line 6)
3822 * options, and recursion: Options/Recursion. (line 6)
3823 * options, setting from environment: Options/Recursion. (line 81)
3824 * options, setting in makefiles: Options/Recursion. (line 81)
3825 * order of pattern rules: Pattern Intro. (line 57)
3826 * order-only prerequisites: Prerequisite Types. (line 6)
3827 * origin of variable: Origin Function. (line 6)
3828 * overriding makefiles: Overriding Makefiles.
3830 * overriding variables with arguments: Overriding. (line 6)
3831 * overriding with override: Override Directive. (line 6)
3832 * parallel execution: Parallel. (line 6)
3833 * parallel execution, and archive update: Archive Pitfalls. (line 6)
3834 * parallel execution, overriding: Special Targets. (line 135)
3835 * parts of makefile rule: Rule Introduction. (line 6)
3836 * Pascal, rule to compile: Catalogue of Rules. (line 45)
3837 * pattern rule: Pattern Intro. (line 6)
3838 * pattern rule, expansion: Reading Makefiles. (line 62)
3839 * pattern rules, order of: Pattern Intro. (line 57)
3840 * pattern rules, static (not implicit): Static Pattern. (line 6)
3841 * pattern rules, static, syntax of: Static Usage. (line 6)
3842 * pattern-specific variables: Pattern-specific. (line 6)
3843 * pc <1>: Implicit Variables. (line 84)
3844 * pc: Catalogue of Rules. (line 45)
3845 * phony targets: Phony Targets. (line 6)
3846 * pitfalls of wildcards: Wildcard Pitfall. (line 6)
3847 * portability: Features. (line 6)
3848 * POSIX: Overview. (line 13)
3849 * POSIX.2: Options/Recursion. (line 60)
3850 * post-installation commands: Install Command Categories.
3852 * pre-installation commands: Install Command Categories.
3854 * precious targets: Special Targets. (line 29)
3855 * predefined rules and variables, printing: Options Summary. (line 155)
3856 * prefix, adding: File Name Functions. (line 79)
3857 * prerequisite: Rules. (line 6)
3858 * prerequisite pattern, implicit: Pattern Intro. (line 22)
3859 * prerequisite pattern, static (not implicit): Static Usage. (line 30)
3860 * prerequisite types: Prerequisite Types. (line 6)
3861 * prerequisite, expansion: Reading Makefiles. (line 62)
3862 * prerequisites: Rule Syntax. (line 46)
3863 * prerequisites, and automatic variables: Automatic Variables.
3865 * prerequisites, automatic generation <1>: Automatic Prerequisites.
3867 * prerequisites, automatic generation: Include. (line 50)
3868 * prerequisites, introduction to: Rule Introduction. (line 8)
3869 * prerequisites, list of all: Automatic Variables. (line 61)
3870 * prerequisites, list of changed: Automatic Variables. (line 51)
3871 * prerequisites, normal: Prerequisite Types. (line 6)
3872 * prerequisites, order-only: Prerequisite Types. (line 6)
3873 * prerequisites, varying (static pattern): Static Pattern. (line 6)
3874 * preserving intermediate files: Chained Rules. (line 46)
3875 * preserving with .PRECIOUS <1>: Chained Rules. (line 56)
3876 * preserving with .PRECIOUS: Special Targets. (line 29)
3877 * preserving with .SECONDARY: Special Targets. (line 49)
3878 * print (standard target): Goals. (line 97)
3879 * print target <1>: Empty Targets. (line 25)
3880 * print target: Wildcard Examples. (line 21)
3881 * printing directories: -w Option. (line 6)
3882 * printing messages: Make Control Functions.
3884 * printing of commands: Echoing. (line 6)
3885 * printing user warnings: Make Control Functions.
3887 * problems and bugs, reporting: Bugs. (line 6)
3888 * problems with wildcards: Wildcard Pitfall. (line 6)
3889 * processing a makefile: How Make Works. (line 6)
3890 * question mode: Instead of Execution.
3892 * quoting %, in patsubst: Text Functions. (line 26)
3893 * quoting %, in static pattern: Static Usage. (line 37)
3894 * quoting %, in vpath: Selective Search. (line 38)
3895 * quoting newline, in commands: Splitting Lines. (line 6)
3896 * quoting newline, in makefile: Simple Makefile. (line 40)
3897 * Ratfor, rule to compile: Catalogue of Rules. (line 49)
3898 * RCS, rule to extract from: Catalogue of Rules. (line 164)
3899 * reading makefiles: Reading Makefiles. (line 6)
3900 * README: Makefile Names. (line 9)
3901 * realclean (standard target): Goals. (line 85)
3902 * realpath: File Name Functions. (line 114)
3903 * recompilation: Introduction. (line 22)
3904 * recompilation, avoiding: Avoiding Compilation.
3906 * recording events with empty targets: Empty Targets. (line 6)
3907 * recursion: Recursion. (line 6)
3908 * recursion, and -C: Options/Recursion. (line 22)
3909 * recursion, and -f: Options/Recursion. (line 22)
3910 * recursion, and -j: Options/Recursion. (line 25)
3911 * recursion, and -o: Options/Recursion. (line 22)
3912 * recursion, and -t: MAKE Variable. (line 34)
3913 * recursion, and -w: -w Option. (line 20)
3914 * recursion, and -W: Options/Recursion. (line 22)
3915 * recursion, and command line variable definitions: Options/Recursion.
3917 * recursion, and environment: Variables/Recursion. (line 6)
3918 * recursion, and MAKE variable: MAKE Variable. (line 6)
3919 * recursion, and MAKEFILES variable: MAKEFILES Variable. (line 14)
3920 * recursion, and options: Options/Recursion. (line 6)
3921 * recursion, and printing directories: -w Option. (line 6)
3922 * recursion, and variables: Variables/Recursion. (line 6)
3923 * recursion, level of: Variables/Recursion. (line 115)
3924 * recursive variable expansion <1>: Flavors. (line 6)
3925 * recursive variable expansion: Using Variables. (line 6)
3926 * recursively expanded variables: Flavors. (line 6)
3927 * reference to variables <1>: Advanced. (line 6)
3928 * reference to variables: Reference. (line 6)
3929 * relinking: How Make Works. (line 46)
3930 * remaking makefiles: Remaking Makefiles. (line 6)
3931 * removal of target files <1>: Interrupts. (line 6)
3932 * removal of target files: Errors. (line 64)
3933 * removing duplicate words: Text Functions. (line 155)
3934 * removing targets on failure: Special Targets. (line 68)
3935 * removing, to clean up: Cleanup. (line 6)
3936 * reporting bugs: Bugs. (line 6)
3937 * rm: Implicit Variables. (line 110)
3938 * rm (shell command) <1>: Errors. (line 27)
3939 * rm (shell command) <2>: Phony Targets. (line 20)
3940 * rm (shell command) <3>: Wildcard Examples. (line 12)
3941 * rm (shell command): Simple Makefile. (line 83)
3942 * rule commands: Commands. (line 6)
3943 * rule prerequisites: Rule Syntax. (line 46)
3944 * rule syntax: Rule Syntax. (line 6)
3945 * rule targets: Rule Syntax. (line 18)
3946 * rule, double-colon (::): Double-Colon. (line 6)
3947 * rule, explicit, definition of: Makefile Contents. (line 10)
3948 * rule, how to write: Rules. (line 6)
3949 * rule, implicit: Implicit Rules. (line 6)
3950 * rule, implicit, and directory search: Implicit/Search. (line 6)
3951 * rule, implicit, and VPATH: Implicit/Search. (line 6)
3952 * rule, implicit, chains of: Chained Rules. (line 6)
3953 * rule, implicit, definition of: Makefile Contents. (line 16)
3954 * rule, implicit, how to use: Using Implicit. (line 6)
3955 * rule, implicit, introduction to: make Deduces. (line 6)
3956 * rule, implicit, predefined: Catalogue of Rules. (line 6)
3957 * rule, introduction to: Rule Introduction. (line 6)
3958 * rule, multiple for one target: Multiple Rules. (line 6)
3959 * rule, no commands or prerequisites: Force Targets. (line 6)
3960 * rule, pattern: Pattern Intro. (line 6)
3961 * rule, static pattern: Static Pattern. (line 6)
3962 * rule, static pattern versus implicit: Static versus Implicit.
3964 * rule, with multiple targets: Multiple Targets. (line 6)
3965 * rules, and $: Rule Syntax. (line 32)
3966 * s. (SCCS file prefix): Catalogue of Rules. (line 173)
3967 * SCCS, rule to extract from: Catalogue of Rules. (line 173)
3968 * search algorithm, implicit rule: Implicit Rule Search.
3970 * search path for prerequisites (VPATH): Directory Search. (line 6)
3971 * search path for prerequisites (VPATH), and implicit rules: Implicit/Search.
3973 * search path for prerequisites (VPATH), and link libraries: Libraries/Search.
3975 * searching for strings: Text Functions. (line 103)
3976 * secondary expansion: Secondary Expansion. (line 6)
3977 * secondary expansion and explicit rules: Secondary Expansion.
3979 * secondary expansion and implicit rules: Secondary Expansion.
3981 * secondary expansion and static pattern rules: Secondary Expansion.
3983 * secondary files: Chained Rules. (line 46)
3984 * secondary targets: Special Targets. (line 49)
3985 * sed (shell command): Automatic Prerequisites.
3987 * selecting a word: Text Functions. (line 159)
3988 * selecting word lists: Text Functions. (line 168)
3989 * sequences of commands: Sequences. (line 6)
3990 * setting options from environment: Options/Recursion. (line 81)
3991 * setting options in makefiles: Options/Recursion. (line 81)
3992 * setting variables: Setting. (line 6)
3993 * several rules for one target: Multiple Rules. (line 6)
3994 * several targets in a rule: Multiple Targets. (line 6)
3995 * shar (standard target): Goals. (line 103)
3996 * shell command: Simple Makefile. (line 72)
3997 * shell command, and directory search: Commands/Search. (line 6)
3998 * shell command, execution: Execution. (line 6)
3999 * shell command, function for: Shell Function. (line 6)
4000 * shell file name pattern (in include): Include. (line 13)
4001 * shell variables, setting in commands: Execution. (line 10)
4002 * shell wildcards (in include): Include. (line 13)
4003 * shell, choosing the: Choosing the Shell. (line 6)
4004 * SHELL, exported value: Variables/Recursion. (line 23)
4005 * SHELL, import from environment: Environment. (line 37)
4006 * shell, in DOS and Windows: Choosing the Shell. (line 36)
4007 * SHELL, MS-DOS specifics: Choosing the Shell. (line 42)
4008 * SHELL, value of: Choosing the Shell. (line 6)
4009 * signal: Interrupts. (line 6)
4010 * silent operation: Echoing. (line 6)
4011 * simple makefile: Simple Makefile. (line 6)
4012 * simple variable expansion: Using Variables. (line 6)
4013 * simplifying with variables: Variables Simplify. (line 6)
4014 * simply expanded variables: Flavors. (line 56)
4015 * sorting words: Text Functions. (line 146)
4016 * spaces, in variable values: Flavors. (line 103)
4017 * spaces, stripping: Text Functions. (line 80)
4018 * special targets: Special Targets. (line 6)
4019 * special variables: Special Variables. (line 6)
4020 * specifying makefile name: Makefile Names. (line 30)
4021 * splitting commands: Splitting Lines. (line 6)
4022 * standard input: Parallel. (line 30)
4023 * standards conformance: Overview. (line 13)
4024 * standards for makefiles: Makefile Conventions.
4026 * static pattern rule: Static Pattern. (line 6)
4027 * static pattern rule, syntax of: Static Usage. (line 6)
4028 * static pattern rule, versus implicit: Static versus Implicit.
4030 * static pattern rules, secondary expansion of: Secondary Expansion.
4032 * stem <1>: Pattern Match. (line 6)
4033 * stem: Static Usage. (line 17)
4034 * stem, variable for: Automatic Variables. (line 77)
4035 * stopping make: Make Control Functions.
4037 * strings, searching for: Text Functions. (line 103)
4038 * stripping whitespace: Text Functions. (line 80)
4039 * sub-make: Variables/Recursion. (line 6)
4040 * subdirectories, recursion for: Recursion. (line 6)
4041 * substitution variable reference: Substitution Refs. (line 6)
4042 * suffix rule: Suffix Rules. (line 6)
4043 * suffix rule, for archive: Archive Suffix Rules.
4045 * suffix, adding: File Name Functions. (line 68)
4046 * suffix, function to find: File Name Functions. (line 43)
4047 * suffix, substituting in variables: Substitution Refs. (line 6)
4048 * switches: Options Summary. (line 6)
4049 * symbol directories, updating archive: Archive Symbols. (line 6)
4050 * syntax of commands: Command Syntax. (line 6)
4051 * syntax of rules: Rule Syntax. (line 6)
4052 * tab character (in commands): Rule Syntax. (line 26)
4053 * tabs in rules: Rule Introduction. (line 21)
4054 * TAGS (standard target): Goals. (line 111)
4055 * tangle <1>: Implicit Variables. (line 104)
4056 * tangle: Catalogue of Rules. (line 151)
4057 * tar (standard target): Goals. (line 100)
4058 * target: Rules. (line 6)
4059 * target pattern, implicit: Pattern Intro. (line 9)
4060 * target pattern, static (not implicit): Static Usage. (line 17)
4061 * target, deleting on error: Errors. (line 64)
4062 * target, deleting on interrupt: Interrupts. (line 6)
4063 * target, expansion: Reading Makefiles. (line 62)
4064 * target, multiple in pattern rule: Pattern Intro. (line 49)
4065 * target, multiple rules for one: Multiple Rules. (line 6)
4066 * target, touching: Instead of Execution.
4068 * target-specific variables: Target-specific. (line 6)
4069 * targets: Rule Syntax. (line 18)
4070 * targets without a file: Phony Targets. (line 6)
4071 * targets, built-in special: Special Targets. (line 6)
4072 * targets, empty: Empty Targets. (line 6)
4073 * targets, force: Force Targets. (line 6)
4074 * targets, introduction to: Rule Introduction. (line 8)
4075 * targets, multiple: Multiple Targets. (line 6)
4076 * targets, phony: Phony Targets. (line 6)
4077 * terminal rule: Match-Anything Rules.
4079 * test (standard target): Goals. (line 115)
4080 * testing compilation: Testing. (line 6)
4081 * tex <1>: Implicit Variables. (line 91)
4082 * tex: Catalogue of Rules. (line 151)
4083 * TeX, rule to run: Catalogue of Rules. (line 151)
4084 * texi2dvi <1>: Implicit Variables. (line 95)
4085 * texi2dvi: Catalogue of Rules. (line 158)
4086 * Texinfo, rule to format: Catalogue of Rules. (line 158)
4087 * tilde (~): Wildcards. (line 11)
4088 * touch (shell command) <1>: Empty Targets. (line 25)
4089 * touch (shell command): Wildcard Examples. (line 21)
4090 * touching files: Instead of Execution.
4092 * traditional directory search (GPATH): Search Algorithm. (line 42)
4093 * types of prerequisites: Prerequisite Types. (line 6)
4094 * undefined variables, warning message: Options Summary. (line 251)
4095 * updating archive symbol directories: Archive Symbols. (line 6)
4096 * updating makefiles: Remaking Makefiles. (line 6)
4097 * user defined functions: Call Function. (line 6)
4098 * value: Using Variables. (line 6)
4099 * value, how a variable gets it: Values. (line 6)
4100 * variable: Using Variables. (line 6)
4101 * variable definition: Makefile Contents. (line 22)
4102 * variable references in commands: Variables in Commands.
4104 * variables: Variables Simplify. (line 6)
4105 * variables, $ in name: Computed Names. (line 6)
4106 * variables, and implicit rule: Automatic Variables. (line 6)
4107 * variables, appending to: Appending. (line 6)
4108 * variables, automatic: Automatic Variables. (line 6)
4109 * variables, command line: Overriding. (line 6)
4110 * variables, command line, and recursion: Options/Recursion. (line 17)
4111 * variables, computed names: Computed Names. (line 6)
4112 * variables, conditional assignment: Flavors. (line 129)
4113 * variables, defining verbatim: Defining. (line 6)
4114 * variables, environment <1>: Environment. (line 6)
4115 * variables, environment: Variables/Recursion. (line 6)
4116 * variables, exporting: Variables/Recursion. (line 6)
4117 * variables, flavor of: Flavor Function. (line 6)
4118 * variables, flavors: Flavors. (line 6)
4119 * variables, how they get their values: Values. (line 6)
4120 * variables, how to reference: Reference. (line 6)
4121 * variables, loops in expansion: Flavors. (line 44)
4122 * variables, modified reference: Substitution Refs. (line 6)
4123 * variables, nested references: Computed Names. (line 6)
4124 * variables, origin of: Origin Function. (line 6)
4125 * variables, overriding: Override Directive. (line 6)
4126 * variables, overriding with arguments: Overriding. (line 6)
4127 * variables, pattern-specific: Pattern-specific. (line 6)
4128 * variables, recursively expanded: Flavors. (line 6)
4129 * variables, setting: Setting. (line 6)
4130 * variables, simply expanded: Flavors. (line 56)
4131 * variables, spaces in values: Flavors. (line 103)
4132 * variables, substituting suffix in: Substitution Refs. (line 6)
4133 * variables, substitution reference: Substitution Refs. (line 6)
4134 * variables, target-specific: Target-specific. (line 6)
4135 * variables, unexpanded value: Value Function. (line 6)
4136 * variables, warning for undefined: Options Summary. (line 251)
4137 * varying prerequisites: Static Pattern. (line 6)
4138 * verbatim variable definition: Defining. (line 6)
4139 * vpath: Directory Search. (line 6)
4140 * VPATH, and implicit rules: Implicit/Search. (line 6)
4141 * VPATH, and link libraries: Libraries/Search. (line 6)
4142 * warnings, printing: Make Control Functions.
4144 * weave <1>: Implicit Variables. (line 98)
4145 * weave: Catalogue of Rules. (line 151)
4146 * Web, rule to run: Catalogue of Rules. (line 151)
4147 * what if: Instead of Execution.
4149 * whitespace, in variable values: Flavors. (line 103)
4150 * whitespace, stripping: Text Functions. (line 80)
4151 * wildcard: Wildcards. (line 6)
4152 * wildcard pitfalls: Wildcard Pitfall. (line 6)
4153 * wildcard, function: File Name Functions. (line 107)
4154 * wildcard, in archive member: Archive Members. (line 36)
4155 * wildcard, in include: Include. (line 13)
4156 * wildcards and MS-DOS/MS-Windows backslashes: Wildcard Pitfall.
4158 * Windows, choosing a shell in: Choosing the Shell. (line 36)
4159 * word, selecting a: Text Functions. (line 159)
4160 * words, extracting first: Text Functions. (line 184)
4161 * words, extracting last: Text Functions. (line 197)
4162 * words, filtering: Text Functions. (line 114)
4163 * words, filtering out: Text Functions. (line 132)
4164 * words, finding number: Text Functions. (line 180)
4165 * words, iterating over: Foreach Function. (line 6)
4166 * words, joining lists: File Name Functions. (line 90)
4167 * words, removing duplicates: Text Functions. (line 155)
4168 * words, selecting lists of: Text Functions. (line 168)
4169 * writing rule commands: Commands. (line 6)
4170 * writing rules: Rules. (line 6)
4171 * yacc <1>: Implicit Variables. (line 75)
4172 * yacc <2>: Catalogue of Rules. (line 120)
4173 * yacc: Sequences. (line 18)
4174 * Yacc, rule to run: Catalogue of Rules. (line 120)
4175 * ~ (tilde): Wildcards. (line 11)
4178 File: make.info, Node: Name Index, Prev: Concept Index, Up: Top
4180 Index of Functions, Variables, & Directives
4181 *******************************************
4186 * $%: Automatic Variables. (line 37)
4187 * $(%D): Automatic Variables. (line 129)
4188 * $(%F): Automatic Variables. (line 130)
4189 * $(*D): Automatic Variables. (line 124)
4190 * $(*F): Automatic Variables. (line 125)
4191 * $(+D): Automatic Variables. (line 147)
4192 * $(+F): Automatic Variables. (line 148)
4193 * $(<D): Automatic Variables. (line 137)
4194 * $(<F): Automatic Variables. (line 138)
4195 * $(?D): Automatic Variables. (line 153)
4196 * $(?F): Automatic Variables. (line 154)
4197 * $(@D): Automatic Variables. (line 113)
4198 * $(@F): Automatic Variables. (line 119)
4199 * $(^D): Automatic Variables. (line 142)
4200 * $(^F): Automatic Variables. (line 143)
4201 * $*: Automatic Variables. (line 73)
4202 * $*, and static pattern: Static Usage. (line 81)
4203 * $+: Automatic Variables. (line 63)
4204 * $<: Automatic Variables. (line 43)
4205 * $?: Automatic Variables. (line 48)
4206 * $@: Automatic Variables. (line 30)
4207 * $^: Automatic Variables. (line 53)
4208 * $|: Automatic Variables. (line 69)
4209 * % (automatic variable): Automatic Variables. (line 37)
4210 * %D (automatic variable): Automatic Variables. (line 129)
4211 * %F (automatic variable): Automatic Variables. (line 130)
4212 * * (automatic variable): Automatic Variables. (line 73)
4213 * * (automatic variable), unsupported bizarre usage: Missing. (line 44)
4214 * *D (automatic variable): Automatic Variables. (line 124)
4215 * *F (automatic variable): Automatic Variables. (line 125)
4216 * + (automatic variable): Automatic Variables. (line 63)
4217 * +D (automatic variable): Automatic Variables. (line 147)
4218 * +F (automatic variable): Automatic Variables. (line 148)
4219 * .DEFAULT <1>: Last Resort. (line 23)
4220 * .DEFAULT: Special Targets. (line 20)
4221 * .DEFAULT, and empty commands: Empty Commands. (line 16)
4222 * .DEFAULT_GOAL (define default goal): Special Variables. (line 10)
4223 * .DELETE_ON_ERROR <1>: Errors. (line 64)
4224 * .DELETE_ON_ERROR: Special Targets. (line 67)
4225 * .EXPORT_ALL_VARIABLES <1>: Variables/Recursion. (line 99)
4226 * .EXPORT_ALL_VARIABLES: Special Targets. (line 129)
4227 * .FEATURES (list of supported features): Special Variables. (line 65)
4228 * .IGNORE <1>: Errors. (line 30)
4229 * .IGNORE: Special Targets. (line 74)
4230 * .INCLUDE_DIRS (list of include directories): Special Variables.
4232 * .INTERMEDIATE: Special Targets. (line 43)
4233 * .LIBPATTERNS: Libraries/Search. (line 6)
4234 * .LOW_RESOLUTION_TIME: Special Targets. (line 86)
4235 * .NOTPARALLEL: Special Targets. (line 134)
4236 * .PHONY <1>: Special Targets. (line 8)
4237 * .PHONY: Phony Targets. (line 22)
4238 * .POSIX: Options/Recursion. (line 60)
4239 * .PRECIOUS <1>: Interrupts. (line 22)
4240 * .PRECIOUS: Special Targets. (line 28)
4241 * .SECONDARY: Special Targets. (line 48)
4242 * .SECONDEXPANSION <1>: Special Targets. (line 57)
4243 * .SECONDEXPANSION: Secondary Expansion. (line 6)
4244 * .SILENT <1>: Echoing. (line 24)
4245 * .SILENT: Special Targets. (line 116)
4246 * .SUFFIXES <1>: Suffix Rules. (line 61)
4247 * .SUFFIXES: Special Targets. (line 15)
4248 * .VARIABLES (list of variables): Special Variables. (line 56)
4249 * /usr/gnu/include: Include. (line 52)
4250 * /usr/include: Include. (line 52)
4251 * /usr/local/include: Include. (line 52)
4252 * < (automatic variable): Automatic Variables. (line 43)
4253 * <D (automatic variable): Automatic Variables. (line 137)
4254 * <F (automatic variable): Automatic Variables. (line 138)
4255 * ? (automatic variable): Automatic Variables. (line 48)
4256 * ?D (automatic variable): Automatic Variables. (line 153)
4257 * ?F (automatic variable): Automatic Variables. (line 154)
4258 * @ (automatic variable): Automatic Variables. (line 30)
4259 * @D (automatic variable): Automatic Variables. (line 113)
4260 * @F (automatic variable): Automatic Variables. (line 119)
4261 * ^ (automatic variable): Automatic Variables. (line 53)
4262 * ^D (automatic variable): Automatic Variables. (line 142)
4263 * ^F (automatic variable): Automatic Variables. (line 143)
4264 * abspath: File Name Functions. (line 121)
4265 * addprefix: File Name Functions. (line 79)
4266 * addsuffix: File Name Functions. (line 68)
4267 * and: Conditional Functions.
4269 * AR: Implicit Variables. (line 41)
4270 * ARFLAGS: Implicit Variables. (line 117)
4271 * AS: Implicit Variables. (line 44)
4272 * ASFLAGS: Implicit Variables. (line 120)
4273 * basename: File Name Functions. (line 57)
4274 * bindir: Directory Variables. (line 53)
4275 * call: Call Function. (line 6)
4276 * CC: Implicit Variables. (line 47)
4277 * CFLAGS: Implicit Variables. (line 124)
4278 * CO: Implicit Variables. (line 50)
4279 * COFLAGS: Implicit Variables. (line 130)
4280 * COMSPEC: Choosing the Shell. (line 39)
4281 * CPP: Implicit Variables. (line 59)
4282 * CPPFLAGS: Implicit Variables. (line 133)
4283 * CTANGLE: Implicit Variables. (line 107)
4284 * CURDIR: Recursion. (line 28)
4285 * CWEAVE: Implicit Variables. (line 101)
4286 * CXX: Implicit Variables. (line 53)
4287 * CXXFLAGS: Implicit Variables. (line 127)
4288 * define: Defining. (line 6)
4289 * dir: File Name Functions. (line 17)
4290 * else: Conditional Syntax. (line 6)
4291 * endef: Defining. (line 6)
4292 * endif: Conditional Syntax. (line 6)
4293 * error: Make Control Functions.
4295 * eval: Eval Function. (line 6)
4296 * exec_prefix: Directory Variables. (line 35)
4297 * export: Variables/Recursion. (line 40)
4298 * FC: Implicit Variables. (line 63)
4299 * FFLAGS: Implicit Variables. (line 137)
4300 * filter: Text Functions. (line 114)
4301 * filter-out: Text Functions. (line 132)
4302 * findstring: Text Functions. (line 103)
4303 * firstword: Text Functions. (line 184)
4304 * flavor: Flavor Function. (line 6)
4305 * foreach: Foreach Function. (line 6)
4306 * GET: Implicit Variables. (line 67)
4307 * GFLAGS: Implicit Variables. (line 140)
4308 * GNUmakefile: Makefile Names. (line 7)
4309 * GPATH: Search Algorithm. (line 48)
4310 * if: Conditional Functions.
4312 * ifdef: Conditional Syntax. (line 6)
4313 * ifeq: Conditional Syntax. (line 6)
4314 * ifndef: Conditional Syntax. (line 6)
4315 * ifneq: Conditional Syntax. (line 6)
4316 * include: Include. (line 6)
4317 * info: Make Control Functions.
4319 * join: File Name Functions. (line 90)
4320 * lastword: Text Functions. (line 197)
4321 * LDFLAGS: Implicit Variables. (line 143)
4322 * LEX: Implicit Variables. (line 70)
4323 * LFLAGS: Implicit Variables. (line 147)
4324 * libexecdir: Directory Variables. (line 66)
4325 * LINT: Implicit Variables. (line 78)
4326 * LINTFLAGS: Implicit Variables. (line 159)
4327 * M2C: Implicit Variables. (line 81)
4328 * MAKE <1>: Flavors. (line 84)
4329 * MAKE: MAKE Variable. (line 6)
4330 * MAKE_RESTARTS (number of times make has restarted): Special Variables.
4332 * MAKE_VERSION: Features. (line 197)
4333 * MAKECMDGOALS: Goals. (line 30)
4334 * makefile: Makefile Names. (line 7)
4335 * Makefile: Makefile Names. (line 7)
4336 * MAKEFILE_LIST: MAKEFILE_LIST Variable.
4338 * MAKEFILES <1>: Variables/Recursion. (line 127)
4339 * MAKEFILES: MAKEFILES Variable. (line 6)
4340 * MAKEFLAGS: Options/Recursion. (line 6)
4341 * MAKEINFO: Implicit Variables. (line 87)
4342 * MAKELEVEL <1>: Flavors. (line 84)
4343 * MAKELEVEL: Variables/Recursion. (line 115)
4344 * MAKEOVERRIDES: Options/Recursion. (line 49)
4345 * MAKESHELL (MS-DOS alternative to SHELL): Choosing the Shell.
4347 * MFLAGS: Options/Recursion. (line 65)
4348 * notdir: File Name Functions. (line 27)
4349 * or: Conditional Functions.
4351 * origin: Origin Function. (line 6)
4352 * OUTPUT_OPTION: Catalogue of Rules. (line 202)
4353 * override: Override Directive. (line 6)
4354 * patsubst <1>: Text Functions. (line 18)
4355 * patsubst: Substitution Refs. (line 28)
4356 * PC: Implicit Variables. (line 84)
4357 * PFLAGS: Implicit Variables. (line 153)
4358 * prefix: Directory Variables. (line 25)
4359 * realpath: File Name Functions. (line 114)
4360 * RFLAGS: Implicit Variables. (line 156)
4361 * RM: Implicit Variables. (line 110)
4362 * sbindir: Directory Variables. (line 59)
4363 * shell: Shell Function. (line 6)
4364 * SHELL: Choosing the Shell. (line 6)
4365 * SHELL (command execution): Execution. (line 6)
4366 * sort: Text Functions. (line 146)
4367 * strip: Text Functions. (line 80)
4368 * subst <1>: Text Functions. (line 9)
4369 * subst: Multiple Targets. (line 28)
4370 * suffix: File Name Functions. (line 43)
4371 * SUFFIXES: Suffix Rules. (line 81)
4372 * TANGLE: Implicit Variables. (line 104)
4373 * TEX: Implicit Variables. (line 91)
4374 * TEXI2DVI: Implicit Variables. (line 94)
4375 * unexport: Variables/Recursion. (line 45)
4376 * value: Value Function. (line 6)
4377 * vpath: Selective Search. (line 6)
4378 * VPATH: General Search. (line 6)
4379 * vpath: Directory Search. (line 6)
4380 * VPATH: Directory Search. (line 6)
4381 * warning: Make Control Functions.
4383 * WEAVE: Implicit Variables. (line 98)
4384 * wildcard <1>: File Name Functions. (line 107)
4385 * wildcard: Wildcard Function. (line 6)
4386 * word: Text Functions. (line 159)
4387 * wordlist: Text Functions. (line 168)
4388 * words: Text Functions. (line 180)
4389 * YACC: Implicit Variables. (line 74)
4390 * YFLAGS: Implicit Variables. (line 150)
4391 * | (automatic variable): Automatic Variables. (line 69)