doc/make.info-2

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