home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 4 / FreshFish_May-June1994.bin / gnu / info / make.info-1 (.txt) < prev    next >
GNU Info File  |  1994-02-21  |  51KB  |  890 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: Top,  Next: Overview,  Prev: (dir),  Up: (dir)
  22.    The GNU `make' utility automatically determines which pieces of a
  23. large program need to be recompiled, and issues the commands to
  24. recompile them.
  25.    This is Edition 0.45 of the `GNU Make Manual', last updated 14
  26. December 1993 for `make' Version 3.70 Beta.
  27.    This manual describes `make' and contains the following chapters:
  28. * Menu:
  29. * Overview::                    Overview of `make'.
  30. * Introduction::                An introduction to `make'.
  31. * Makefiles::                   Makefiles tell `make' what to do.
  32. * Rules::                       Rules describe when a file must be remade.
  33. * Commands::                    Commands say how to remake a file.
  34. * Using Variables::             You can use variables to avoid repetition.
  35. * Conditionals::                Use or ignore parts of the makefile based
  36.                                  on the values of variables.
  37. * Functions::                   Many powerful ways to manipulate text.
  38. * make Invocation: Running.     How to invoke `make' on the command line.
  39. * Implicit Rules::              Use implicit rules to treat many files alike,
  40.                                  based on their file names.
  41. * Archives::                    How `make' can update library archives.
  42. * Features::                    Features GNU `make' has over other `make's.
  43. * Missing::                     What GNU `make' lacks from other `make's.
  44. * Makefile Conventions::        Conventions for makefiles in GNU programs.
  45. * Quick Reference::             A quick reference for experienced users.
  46. * Complex Makefile::            A real example of a straightforward,
  47.                                  but nontrivial, makefile.
  48. * Concept Index::               Index of Concepts
  49. * Name Index::                  Index of Functions, Variables, & Directives
  50.  -- The Detailed Node Listing --
  51. Overview of `make'
  52. * Preparing::                   Preparing and Running Make
  53. * Reading::                     On Reading this Text
  54. * Bugs::                        Problems and Bugs
  55. An Introduction to Makefiles
  56. * Rule Introduction::           What a rule looks like.
  57. * Simple Makefile::             A Simple Makefile
  58. * How Make Works::              How `make' Processes This Makefile
  59. * Variables Simplify::          Variables Make Makefiles Simpler
  60. * make Deduces::                Letting `make' Deduce the Commands
  61. * Combine By Dependency::       Another Style of Makefile
  62. * Cleanup::                     Rules for Cleaning the Directory
  63. Writing Makefiles
  64. * Makefile Contents::           What makefiles contain.
  65. * Makefile Names::              How to name your makefile.
  66. * Include::                     How one makefile can use another makefile.
  67. * MAKEFILES Variable::          The environment can specify extra makefiles.
  68. * Remaking Makefiles::          How makefiles get remade.
  69. * Overriding Makefiles::        How to override part of one makefile
  70.                                  with another makefile.
  71. Writing Rules
  72. * Rule Example::                An example explained.
  73. * Rule Syntax::                 General syntax explained.
  74. * Wildcards::                   Using wildcard characters such as `*'.
  75. * Directory Search::            Searching other directories for source files.
  76. * Phony Targets::               Using a target that is not a real file's name.
  77. * Force Targets::               You can use a target without commands
  78.                                   or dependencies to mark other
  79.                                   targets as phony.
  80. * Empty Targets::               When only the date matters and the
  81.                                   files are empty.
  82. * Special Targets::             Targets with special built-in meanings.
  83. * Multiple Targets::            When to make use of several targets in a rule.
  84. * Multiple Rules::              How to use several rules with the same target.
  85. * Static Pattern::              Static pattern rules apply to multiple targets
  86.                                   and can vary the dependencies according to
  87.                                   the target name.
  88. * Double-Colon::                How to use a special kind of rule to allow
  89.                                   several independent rules for one target.
  90. * Automatic Dependencies::      How to automatically generate rules giving
  91.                                  dependencies from the source files themselves.
  92. Using Wildcard Characters in File Names
  93. * Wildcard Examples::           Several examples
  94. * Wildcard Pitfall::            Problems to avoid.
  95. * Wildcard Function::           How to cause wildcard expansion where
  96.                                   it does not normally take place.
  97. Searching Directories for Dependencies
  98. * General Search::              Specifying a search path that applies
  99.                                   to every dependency.
  100. * Selective Search::            Specifying a search path
  101.                                   for a specified class of names.
  102. * Commands/Search::             How to write shell commands that work together
  103.                                   with search paths.
  104. * Implicit/Search::             How search paths affect implicit rules.
  105. * Libraries/Search::            Directory search for link libraries.
  106. Static Pattern Rules
  107. * Static Usage::                The syntax of static pattern rules.
  108. * Static versus Implicit::      When are they better than implicit rules?
  109. Writing the Commands in Rules
  110. * Echoing::                     How to control when commands are echoed.
  111. * Execution::                   How commands are executed.
  112. * Parallel::                    How commands can be executed in parallel.
  113. * Errors::                      What happens after a command execution error.
  114. * Interrupts::                  What happens when a command is interrupted.
  115. * Recursion::                   Invoking `make' from makefiles.
  116. * Sequences::                   Defining canned sequences of commands.
  117. * Empty Commands::              Defining useful, do-nothing commands.
  118. Recursive Use of `make'
  119. * MAKE Variable::               The special effects of using `$(MAKE)'.
  120. * Variables/Recursion::         How to communicate variables to a sub-`make'.
  121. * Options/Recursion::           How to communicate options to a sub-`make'.
  122. * -w Option::                   How the `-w' or `--print-directory' option
  123.                                  helps debug use of recursive `make' commands.
  124. How to Use Variables
  125. * Reference::                   How to use the value of a variable.
  126. * Flavors::                     Variables come in two flavors.
  127. * Advanced::                    Advanced features for referencing a variable.
  128. * Values::                      All the ways variables get their values.
  129. * Setting::                     How to set a variable in the makefile.
  130. * Appending::                   How to append more text to the old value
  131.                                   of a variable.
  132. * Override Directive::          How to set a variable in the makefile even if
  133.                                   the user has set it with a command argument.
  134. * Defining::