home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 4 / FreshFish_May-June1994.bin / gnu / info / make.info-2 (.txt) < prev    next >
GNU Info File  |  1994-02-21  |  50KB  |  907 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: Rule Syntax,  Next: Wildcards,  Prev: Rule Example,  Up: Rules
  22. Rule Syntax
  23. ===========
  24.    In general, a rule looks like this:
  25.      TARGETS : DEPENDENCIES
  26.              COMMAND
  27.              ...
  28. or like this:
  29.      TARGETS : DEPENDENCIES ; COMMAND
  30.              COMMAND
  31.              ...
  32.    The TARGETS are file names, separated by spaces.  Wildcard
  33. characters may be used (*note Using Wildcard Characters in File Names:
  34. Wildcards.) and a name of the form `A(M)' represents member M in
  35. archive file A (*note Archive Members as Targets: Archive Members.).
  36. Usually there is only one target per rule, but occasionally there is a
  37. reason to have more (*note Multiple Targets in a Rule: Multiple
  38. Targets.).
  39.    The COMMAND lines start with a tab character.  The first command may
  40. appear on the line after the dependencies, with a tab character, or may
  41. appear on the same line, with a semicolon.  Either way, the effect is
  42. the same.  *Note Writing the Commands in Rules: Commands.
  43.    Because dollar signs are used to start variable references, if you
  44. really want a dollar sign in a rule you must write two of them, `$$'
  45. (*note How to Use Variables: Using Variables.).  You may split a long
  46. line by inserting a backslash followed by a newline, but this is not
  47. required, as `make' places no limit on the length of a line in a
  48. makefile.
  49.    A rule tells `make' two things: when the targets are out of date,
  50. and how to update them when necessary.
  51.    The criterion for being out of date is specified in terms of the
  52. DEPENDENCIES, which consist of file names separated by spaces.
  53. (Wildcards and archive members (*note Archives::.) are allowed here
  54. too.) A target is out of date if it does not exist or if it is older
  55. than any of the dependencies (by comparison of last-modification
  56. times).  The idea is that the contents of the target file are computed
  57. based on information in the dependencies, so if any of the dependencies
  58. changes, the contents of the existing target file are no longer
  59. necessarily valid.
  60.    How to update is specified by COMMANDS.  These are lines to be
  61. executed by the shell (normally `sh'), but with some extra features
  62. (*note Writing the Commands in Rules: Commands.).
  63. File: make.info,  Node: Wildcards,  Next: Directory Search,  Prev: Rule Syntax,  Up: Rules
  64. Using Wildcard Characters in File Names
  65. =======================================
  66.    A single file name can specify many files using "wildcard
  67. characters".  The wildcard characters in `make' are `*', `?' and
  68. `[...]', the same as in the Bourne shell.  For example, `*.c' specifies
  69. a list of all the files (in the working directory) whose names end in
  70. `.c'.
  71.    The character `~' at the beginning of a file name also has special
  72. significance.  If alone, or followed by a slash, it represents your home
  73. directory.  For example `~/bin' expands to `/home/you/bin'.  If the `~'
  74. is followed by a word, the string represents the home directory of the
  75. user named by that word.  For example `~john/bin' expands to
  76. `/home/john/bin'.
  77.    Wildcard expansion happens automatically in targets, in dependencies,
  78. and in commands (where the shell does the expansion).  In other
  79. contexts, wildcard expansion happens only if you request it explicitly
  80. with the `wildcard' function.
  81.    The special significance of a wildcard character can be turned off by
  82. preceding it with a backslash.  Thus, `foo\*bar' would refer to a
  83. specific file whose name consists of `foo', an asterisk, and `bar'.
  84. * Menu:
  85. * Wildcard Examples::           Several examples
  86. * Wildcard Pitfall::            Problems to avoid.
  87. * Wildcard Function::           How to cause wildcard expansion where
  88.                                   it does not normally take place.
  89. File: make.info,  Node: Wildcard Examples,  Next: Wildcard Pitfall,  Up: Wildcards
  90. Wildcard Examples
  91. -----------------
  92.    Wildcards can be used in the commands of a rule, where they are
  93. expanded by the shell.  For example, here is a rule to delete all the
  94. object files:
  95.      clean:
  96.              rm -f *.o
  97.    Wildcards are also useful in the dependencies of a rule.  With the
  98. following rule in the makefile, `make print' will print all the `.c'
  99. files that have changed since the last time you printed them:
  100.      print: *.c
  101.              lpr -p $?
  102.              touch print
  103. This rule uses `print' as an empty target file; see *Note Empty Target
  104. Files to Record Events: Empty Targets.  (The automatic variable `$?' is
  105. used to print only those files that have changed; see *Note Automatic
  106. Variables: Automatic.)
  107.    Wildcard expansion does not happen when you define a variable.
  108. Thus, if you write this:
  109.      objects = *.o
  110. then the value of the variable `objects' is the actual string `*.o'.
  111. However, if you use the value of `objects' in a target, dependency or
  112. command, wildcard expansion will take place at that time.  To set
  113. `objects' to the expansion, instead use:
  114.      objects := $(wildcard *.o)
  115. *Note Wildcard Function::.
  116. File: make.info,  Node: Wildcard Pitfall,  Next: Wildcard Function,  Prev: Wildcard Examples,  Up: Wildcards
  117. Pitfalls of Using Wildcards
  118. ---------------------------
  119.    Now here is an example of a naive way of using wildcard expansion,
  120. that does not do what you would intend.  Suppose you would like to say
  121. that the executable file `foo' is made from all the object files in the
  122. directory, and you write this:
  123.      objects = *.o
  124.      
  125.      foo : $(objects)
  126.              cc -o foo $(CFLAGS) $(objects)
  127. The value of `objects' is the actual string `*.o'.  Wildcard expansion
  128. happens in the rule for `foo', so that each *existing* `.o' file
  129. becomes a dependency of `foo' and will be recompiled if necessary.
  130.    But what if you delete all the `.o' files?  When a wildcard matches
  131. no files, it is left as it is, so then `foo' will depend on the
  132. oddly-named file `*.o'.  Since so such file is likely to exist, `make'
  133. will give you an error saying it cannot figure out how to make `*.o'.
  134. This is not what you want!
  135.    Actually it is possible to obtain the desired result with wildcard
  136. expansion, but you need more sophisticated techniques, including the
  137. `wildcard' function and string substitution.  *Note The Function
  138. `wildcard': Wildcard Function.
  139. File: make.info,  Node: Wildcard Function,  Prev: Wildcard Pitfall,  Up: Wildcards
  140. The Function `wildcard'
  141. -----------------------
  142.    Wildcard expansion happens automatically in rules.  But wildcard
  143. expansion does not normally take place when a variable is set, or
  144. inside the arguments of a function.  If you want to do wildcard
  145. expansion in such places, you need to use the `wildcard' function, like
  146. this:
  147.      $(wildcard PATTERN...)
  148. This string, used anywhere in a makefile, is replaced by a
  149. space-separated list of names of existing files that match one of the
  150. given file name patterns.  If no existing file name matches a pattern,
  151. then that pattern is omitted from the output of the `wildcard'
  152. function.  Note that this is different from how unmatched wildcards
  153. behave in rules, where they are used verbatim rather than ignored
  154. (*note Wildcard Pitfall::.).
  155.    One use of the `wildcard' function is to get