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