home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / gnu / info / make.info-5 (.txt) < prev    next >
GNU Info File  |  1994-06-22  |  50KB  |  895 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 11 May 1994, of `The GNU Make
  7. Manual', for `make', Version 3.71 Beta.
  8.    Copyright (C) 1988, '89, '90, '91, '92, '93, '94 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: Options Summary,  Prev: Testing,  Up: Running
  22. Summary of Options
  23. ==================
  24.    Here is a table of all the options `make' understands:
  25.      These options are ignored for compatibility with other versions of
  26.      `make'.
  27. `-C DIR'
  28. `--directory=DIR'
  29.      Change to directory DIR before reading the makefiles.  If multiple
  30.      `-C' options are specified, each is interpreted relative to the
  31.      previous one: `-C / -C etc' is equivalent to `-C /etc'.  This is
  32.      typically used with recursive invocations of `make' (*note
  33.      Recursive Use of `make': Recursion.).
  34. `--debug'
  35.      Print debugging information in addition to normal processing.  The
  36.      debugging information says which files are being considered for
  37.      remaking, which file-times are being compared and with what
  38.      results, which files actually need to be remade, which implicit
  39.      rules are considered and which are applied--everything interesting
  40.      about how `make' decides what to do.
  41. `--environment-overrides'
  42.      Give variables taken from the environment precedence over
  43.      variables from makefiles.  *Note Variables from the Environment:
  44.      Environment.
  45. `-f FILE'
  46. `--file=FILE'
  47. `--makefile=FILE'
  48.      Read the file named FILE as a makefile.  *Note Writing Makefiles:
  49.      Makefiles.
  50. `--help'
  51.      Remind you of the options that `make' understands and then exit.
  52. `--ignore-errors'
  53.      Ignore all errors in commands executed to remake files.  *Note
  54.      Errors in Commands: Errors.
  55. `-I DIR'
  56. `--include-dir=DIR'
  57.      Specifies a directory DIR to search for included makefiles.  *Note
  58.      Including Other Makefiles: Include.  If several `-I' options are
  59.      used to specify several directories, the directories are searched
  60.      in the order specified.
  61. `-j [JOBS]'
  62. `--jobs=[JOBS]'
  63.      Specifies the number of jobs (commands) to run simultaneously.
  64.      With no argument, `make' runs as many jobs simultaneously as
  65.      possible.  If there is more than one `-j' option, the last one is
  66.      effective.  *Note Parallel Execution: Parallel, for more
  67.      information on how commands are run.
  68. `--keep-going'
  69.      Continue as much as possible after an error.  While the target that
  70.      failed, and those that depend on it, cannot be remade, the other
  71.      dependencies of these targets can be processed all the same.
  72.      *Note Testing the Compilation of a Program: Testing.
  73. `-l [LOAD]'
  74. `--load-average[=LOAD]'
  75. `--max-load[=LOAD]'
  76.      Specifies that no new jobs (commands) should be started if there
  77.      are other jobs running and the load average is at least LOAD (a
  78.      floating-point number).  With no argument, removes a previous load
  79.      limit.  *Note Parallel Execution: Parallel.
  80. `--just-print'
  81. `--dry-run'
  82. `--recon'
  83.      Print the commands that would be executed, but do not execute them.
  84.      *Note Instead of Executing the Commands: Instead of Execution.
  85. `-o FILE'
  86. `--old-file=FILE'
  87. `--assume-old=FILE'
  88.      Do not remake the file FILE even if it is older than its
  89.      dependencies, and do not remake anything on account of changes in
  90.      FILE.  Essentially the file is treated as very old and its rules
  91.      are ignored.  *Note Avoiding Recompilation of Some Files: Avoiding
  92.      Compilation.
  93. `--print-data-base'
  94.      Print the data base (rules and variable values) that results from
  95.      reading the makefiles; then execute as usual or as otherwise
  96.      specified.  This also prints the version information given by the
  97.      `-v' switch (see below).  To print the data base without trying to
  98.      remake any files, use `make -p -f /dev/null'.
  99. `--question'
  100.      "Question mode".  Do not run any commands, or print anything; just
  101.      return an exit status that is zero if the specified targets are
  102.      already up to date, one if any remaking is required, or two if an
  103.      error is encountered.  *Note Instead of Executing the Commands:
  104.      Instead of Execution.
  105. `--no-builtin-rules'
  106.      Eliminate use of the built-in implicit rules (*note Using Implicit
  107.      Rules: Implicit Rules.).  You can still define your own by writing
  108.      pattern rules (*note Defining and Redefining Pattern Rules:
  109.      Pattern Rules.).  The `-r' option also clears out the default list
  110.      of suffixes for suffix rules (*note Old-Fashioned Suffix Rules:
  111.      Suffix Rules.).  But you can still define your own suffixes with a
  112.      rule for `.SUFFIXES', and then define your own suffix rules.
  113. `--silent'
  114. `--quiet'
  115.      Silent operation; do not print the commands as they are executed.
  116.      *Note Command Echoing: Echoing.
  117. `--no-keep-going'
  118. `--stop'
  119.      Cancel the effect of the `-k' option.  This is never necessary
  120.      except in a recursive `make' where `-k' might be inherited from
  121.      the top-level `make' via `MAKEFLAGS' (*note Recursive Use of
  122.      `make': Recursion.) or if you set `-k' in `MAKEFLAGS' in your
  123.      environment.
  124. `--touch'
  125.      Touch files (mark them up to date without really changing them)
  126.      instead of running their commands.  This is used to pretend that
  127.      the commands were done, in order to fool future invocations of
  128.      `make'.  *Note Instead of Executing the Commands: Instead of
  129.      Execution.
  130. `--version'
  131.      Print the version of the `make' program plus a copyright, a list
  132.      of authors, and a notice that there is no warranty; then exit.
  133. `--print-directory'
  134.      Print a message containing the working directory both before and
  135.      after executing the makefile.  This may be useful for tracking
  136.      down errors from complicated nests of recursive `make' commands.
  137.      *Note Recursive Use of `make': Recursion.  (In practice, you
  138.      rarely need to specify this option since `make' does it for you;
  139.      see *Note The `--print-directory' Option: -w Option.)
  140. `--no-print-directory'
  141.      Disable printing of the working directory under `-w'.  This option
  142.      is useful when `-w' is turned on automatically, but you do not
  143.      want to see the extra messages.  *Note The `--print-directory'
  144.      Option: -w Option.
  145. `-W FILE'
  146. `--what-if=FILE'
  147. `--new-file=FILE'
  148. `--assume-new=FILE'
  149.      Pretend that the target FILE has just been modified.  When used
  150.      with the `-n' flag, this shows you what would happen if you were
  151.      to modify that file.  Without `-n', it is almost the same as
  152.      running a `touch' command on the given file before running `make',
  153.      except that the modification time is changed only in the
  154.      imagination of `make'.  *Note Instead of Executing the Commands:
  155.      Instead of Execution.
  156. `--warn-undefined-variables'
  157.      Issue a warning message whenever `make' sees a reference to an
  158.      undefined variable.  This can be helpful when you are trying to
  159.      debug makefiles which use variables in complex ways.
  160. File: make.info,  Node: Implicit Rules,  Next: Archives,  Prev: Running,  Up: Top
  161. Using Implicit Rules
  162. ********************
  163.    Certain standard ways of remaking target files are used very often.
  164. For example, one customary way to make an object file is from a C
  165. source file using the C compiler, `cc'.
  166.    "Implicit rules" tell `make' how to use customary techniques