home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 4 / FreshFish_May-June1994.bin / gnu / info / make.info-6 (.txt) < prev    next >
GNU Info File  |  1994-02-21  |  48KB  |  870 lines
  1. This is Info file make.info, produced by Makeinfo-1.54 from the input
  2. file ./make.texinfo.
  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.    This is Edition 0.45, last updated 14 December 1993, of `The GNU
  7. Make Manual', for `make', Version 3.70 Beta.
  8.    Copyright (C) 1988, '89, '90, '91, '92, '93 Free Software
  9. Foundation, Inc.
  10.    Permission is granted to make and distribute verbatim copies of this
  11. manual provided the copyright notice and this permission notice are
  12. preserved on all copies.
  13.    Permission is granted to copy and distribute modified versions of
  14. this manual under the conditions for verbatim copying, provided that
  15. the entire resulting derived work is distributed under the terms of a
  16. permission notice identical to this one.
  17.    Permission is granted to copy and distribute translations of this
  18. manual into another language, under the above conditions for modified
  19. versions, except that this permission notice may be stated in a
  20. translation approved by the Free Software Foundation.
  21. File: make.info,  Node: Suffix Rules,  Next: Search Algorithm,  Prev: Last Resort,  Up: Implicit Rules
  22. Old-Fashioned Suffix Rules
  23. ==========================
  24.    "Suffix rules" are the old-fashioned way of defining implicit rules
  25. for `make'.  Suffix rules are obsolete because pattern rules are more
  26. general and clearer.  They are supported in GNU `make' for
  27. compatibility with old makefiles.  They come in two kinds:
  28. "double-suffix" and "single-suffix".
  29.    A double-suffix rule is defined by a pair of suffixes: the target
  30. suffix and the source suffix.  It matches any file whose name ends with
  31. the target suffix.  The corresponding implicit dependency is made by
  32. replacing the target suffix with the source suffix in the file name.  A
  33. two-suffix rule whose target and source suffixes are `.o' and `.c' is
  34. equivalent to the pattern rule `%.o : %.c'.
  35.    A single-suffix rule is defined by a single suffix, which is the
  36. source suffix.  It matches any file name, and the corresponding implicit
  37. dependency name is made by appending the source suffix.  A single-suffix
  38. rule whose source suffix is `.c' is equivalent to the pattern rule `% :
  39. %.c'.
  40.    Suffix rule definitions are recognized by comparing each rule's
  41. target against a defined list of known suffixes.  When `make' sees a
  42. rule whose target is a known suffix, this rule is considered a
  43. single-suffix rule.  When `make' sees a rule whose target is two known
  44. suffixes concatenated, this rule is taken as a double-suffix rule.
  45.    For example, `.c' and `.o' are both on the default list of known
  46. suffixes.  Therefore, if you define a rule whose target is `.c.o',
  47. `make' takes it to be a double-suffix rule with source suffix `.c' and
  48. target suffix `.o'.  Here is the old-fashioned way to define the rule
  49. for compiling a C source file:
  50.      .c.o:
  51.              $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
  52.    Suffix rules cannot have any dependencies of their own.  If they
  53. have any, they are treated as normal files with funny names, not as
  54. suffix rules.  Thus, the rule:
  55.      .c.o: foo.h
  56.              $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
  57. tells how to make the file `.c.o' from the dependency file `foo.h', and
  58. is not at all like the pattern rule:
  59.      %.o: %.c foo.h
  60.              $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
  61. which tells how to make `.o' files from `.c' files, and makes all `.o'
  62. files using this pattern rule also depend on `foo.h'.
  63.    Suffix rules with no commands are also meaningless.  They do not
  64. remove previous rules as do pattern rules with no commands (*note
  65. Canceling Implicit Rules: Canceling Rules.).  They simply enter the
  66. suffix or pair of suffixes concatenated as a target in the data base.
  67.    The known suffixes are simply the names of the dependencies of the
  68. special target `.SUFFIXES'.  You can add your own suffixes by writing a
  69. rule for `.SUFFIXES' that adds more dependencies, as in:
  70.      .SUFFIXES: .hack .win
  71. which adds `.hack' and `.win' to the end of the list of suffixes.
  72.    If you wish to eliminate the default known suffixes instead of just
  73. adding to them, write a rule for `.SUFFIXES' with no dependencies.  By
  74. special dispensation, this eliminates all existing dependencies of
  75. `.SUFFIXES'.  You can then write another rule to add the suffixes you
  76. want.  For example,
  77.      .SUFFIXES:            # Delete the default suffixes
  78.      .SUFFIXES: .c .o .h   # Define our suffix list
  79.    The `-r' or `--no-builtin-rules' flag causes the default list of
  80. suffixes to be empty.
  81.    The variable `SUFFIXES' is defined to the default list of suffixes
  82. before `make' reads any makefiles.  You can change the list of suffixes
  83. with a rule for the special target `.SUFFIXES', but that does not alter
  84. this variable.
  85. File: make.info,  Node: Search Algorithm,  Prev: Suffix Rules,  Up: Implicit Rules
  86. Implicit Rule Search Algorithm
  87. ==============================
  88.    Here is the procedure `make' uses for searching for an implicit rule
  89. for a target T.  This procedure is followed for each double-colon rule
  90. with no commands, for each target of ordinary rules none of which have
  91. commands, and for each dependency that is not the target of any rule.
  92. It is also followed recursively for dependencies that come from implicit
  93. rules, in the search for a chain of rules.
  94.    Suffix rules are not mentioned in this algorithm because suffix
  95. rules are converted to equivalent pattern rules once the makefiles have
  96. been read in.
  97.    For an archive member target of the form `ARCHIVE(MEMBER)', the
  98. following algorithm is run twice, first using the entire target name T,
  99. and second using `(MEMBER)' as the target T if the first run found no
  100. rule.
  101.   1. Split T into a directory part, called D, and the rest, called N.
  102.      For example, if T is `src/foo.o', then D is `src/' and N is
  103.      `foo.o'.
  104.   2. Make a list of all the pattern rules one of whose targets matches
  105.      T or N.  If the target pattern contains a slash, it is matched
  106.      against T; otherwise, against N.
  107.   3. If any rule in that list is *not* a match-anything rule, then
  108.      remove all nonterminal match-anything rules from the list.
  109.   4. Remove from the list all rules with no commands.
  110.   5. For each pattern rule in the list:
  111.        a. Find the stem S, which is the nonempty part of T or N matched
  112.           by the `%' in the target pattern.
  113.        b. Compute the dependency names by substituting S for `%'; if
  114.           the target pattern does not contain a slash, append D to the
  115.           front of each dependency name.
  116.        c. Test whether all the dependencies exist or ought to exist.
  117.           (If a file name is mentioned in the makefile as a target or
  118.           as an explicit dependency, then we say it ought to exist.)
  119.           If all dependencies exist or ought to exist, or there are no
  120.           dependencies, then this rule applies.
  121.   6. If no pattern rule has been found so far, try harder.  For each
  122.      pattern rule in the list:
  123.        a. If the rule is terminal, ignore it and go on to the next rule.
  124.        b. Compute the dependency names as before.
  125.        c. Test whether all the dependencies exist or ought to exist.
  126.        d. For each dependency that does not exist, follow this algorithm
  127.           recursively to see if the dependency can be made by an
  128.           implicit rule.
  129.        e. If all dependencies exist, ought to exist, or can be made by
  130.           implicit rules, then this rule applies.
  131.   7. If no implicit rule applies, the rule for `.DEFAULT', if any,
  132.      applies.  In that case, give T the same commands that `.DEFAULT'
  133.      has.  Otherwise, there are no commands for T.
  134.    Once a rule that applies has been found, for each target pattern of
  135. the rule other than the one that matched T or N, the `%' in the pattern
  136. is replaced with S and the resultant file name is stored until the
  137. commands to remake the target file T are executed.  After these
  138. commands are executed, each of these stored file names are entered into
  139. the data base and marked as having been updated and having the same
  140. update status as the file T.
  141.    When the commands of a pattern rule are executed for T, the automatic
  142. variables are