home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / gnu / make-3.71-src.lha / src / amiga / make-3.71 / make.info-3 (.txt) < prev    next >
GNU Info File  |  1994-05-17  |  50KB  |  923 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: Errors,  Next: Interrupts,  Prev: Parallel,  Up: Commands
  22. Errors in Commands
  23. ==================
  24.    After each shell command returns, `make' looks at its exit status.
  25. If the command completed successfully, the next command line is executed
  26. in a new shell; after the last command line is finished, the rule is
  27. finished.
  28.    If there is an error (the exit status is nonzero), `make' gives up on
  29. the current rule, and perhaps on all rules.
  30.    Sometimes the failure of a certain command does not indicate a
  31. problem.  For example, you may use the `mkdir' command to ensure that a
  32. directory exists.  If the directory already exists, `mkdir' will report
  33. an error, but you probably want `make' to continue regardless.
  34.    To ignore errors in a command line, write a `-' at the beginning of
  35. the line's text (after the initial tab).  The `-' is discarded before
  36. the command is passed to the shell for execution.
  37.    For example,
  38.      clean:
  39.              -rm -f *.o
  40. This causes `rm' to continue even if it is unable to remove a file.
  41.    When you run `make' with the `-i' or `--ignore-errors' flag, errors
  42. are ignored in all commands of all rules.  A rule in the makefile for
  43. the special target `.IGNORE' has the same effect.  These ways of
  44. ignoring errors are obsolete because `-' is more flexible.
  45.    When errors are to be ignored, because of either a `-' or the `-i'
  46. flag, `make' treats an error return just like success, except that it
  47. prints out a message that tells you the status code the command exited
  48. with, and says that the error has been ignored.
  49.    When an error happens that `make' has not been told to ignore, it
  50. implies that the current target cannot be correctly remade, and neither
  51. can any other that depends on it either directly or indirectly.  No
  52. further commands will be executed for these targets, since their
  53. preconditions have not been achieved.
  54.    Normally `make' gives up immediately in this circumstance, returning
  55. a nonzero status.  However, if the `-k' or `--keep-going' flag is
  56. specified, `make' continues to consider the other dependencies of the
  57. pending targets, remaking them if necessary, before it gives up and
  58. returns nonzero status.  For example, after an error in compiling one
  59. object file, `make -k' will continue compiling other object files even
  60. though it already knows that linking them will be impossible.  *Note
  61. Summary of Options: Options Summary.
  62.    The usual behavior assumes that your purpose is to get the specified
  63. targets up to date; once `make' learns that this is impossible, it
  64. might as well report the failure immediately.  The `-k' option says
  65. that the real purpose is to test as many of the changes made in the
  66. program as possible, perhaps to find several independent problems so
  67. that you can correct them all before the next attempt to compile.  This
  68. is why Emacs' `compile' command passes the `-k' flag by default.
  69. File: make.info,  Node: Interrupts,  Next: Recursion,  Prev: Errors,  Up: Commands
  70. Interrupting or Killing `make'
  71. ==============================
  72.    If `make' gets a fatal signal while a command is executing, it may
  73. delete the target file that the command was supposed to update.  This is
  74. done if the target file's last-modification time has changed since
  75. `make' first checked it.
  76.    The purpose of deleting the target is to make sure that it is remade
  77. from scratch when `make' is next run.  Why is this?  Suppose you type
  78. `Ctrl-c' while a compiler is running, and it has begun to write an
  79. object file `foo.o'.  The `Ctrl-c' kills the compiler, resulting in an
  80. incomplete file whose last-modification time is newer than the source
  81. file `foo.c'.  But `make' also receives the `Ctrl-c' signal and deletes
  82. this incomplete file.  If `make' did not do this, the next invocation
  83. of `make' would think that `foo.o' did not require updating--resulting
  84. in a strange error message from the linker when it tries to link an
  85. object file half of which is missing.
  86.    You can prevent the deletion of a target file in this way by making
  87. the special target `.PRECIOUS' depend on it.  Before remaking a target,
  88. `make' checks to see whether it appears on the dependencies of
  89. `.PRECIOUS', and thereby decides whether the target should be deleted
  90. if a signal happens.  Some reasons why you might do this are that the
  91. target is updated in some atomic fashion, or exists only to record a
  92. modification-time (its contents do not matter), or must exist at all
  93. times to prevent other sorts of trouble.
  94. File: make.info,  Node: Recursion,  Next: Sequences,  Prev: Interrupts,  Up: Commands
  95. Recursive Use of `make'
  96. =======================
  97.    Recursive use of `make' means using `make' as a command in a
  98. makefile.  This technique is useful when you want separate makefiles for
  99. various subsystems that compose a larger system.  For example, suppose
  100. you have a subdirectory `subdir' which has its own makefile, and you
  101. would like the containing directory's makefile to run `make' on the
  102. subdirectory.  You can do it by writing this:
  103.      subsystem:
  104.              cd subdir; $(MAKE)
  105. or, equivalently, this (*note Summary of Options: Options Summary.):
  106.      subsystem:
  107.              $(MAKE) -C subdir
  108.    You can write recursive `make' commands just by copying this example,
  109. but there are many things to know about how they work and why, and about
  110. how the sub-`make' relates to the top-level `make'.
  111. * Menu:
  112. * MAKE Variable::               The special effects of using `$(MAKE)'.
  113. * Variables/Recursion::         How to communicate variables to a sub-`make'.
  114. * Options/Recursion::           How to communicate options to a sub-`make'.
  115. * -w Option::                   How the `-w' or `--print-directory' option
  116.                                  helps debug use of recursive `make' commands.
  117. File: make.info,  Node: MAKE Variable,  Next: Variables/Recursion,  Up: Recursion
  118. How the `MAKE' Variable Works
  119. -----------------------------
  120.    Recursive `make' commands should always use the variable `MAKE', not
  121. the explicit command name `make', as shown here:
  122.      subsystem:
  123.              cd subdir; $(MAKE)
  124.    The value of this variable is the file name with which `make' was
  125. invoked.  If this file name was `/bin/make', then the command executed
  126. is `cd subdir; /bin/make'.  If you use a special version of `make' to
  127. run the top-level makefile, the same special version will be executed
  128. for recursive invocations.
  129.    Also, any arguments that define variable values are added to `MAKE',
  130. so the sub-`make' gets them too.  Thus, if you do `make CFLAGS=-O', so
  131. that all C compilations will be optimized, the sub-`make' is run with
  132. `cd subdir; /bin/make CFLAGS=-O'.
  133.    The `MAKE' variable actually just refers to two other variables
  134. which contain these special values.  In fact, `MAKE' is always defined
  135. as `$(MAKE_COMMAND) $(MAKEOVERRIDES)'.  The variable `MAKE_COMMAND' is
  136. the file name with which `make' was invoked (such as `/bin/make',
  137. above).  The variable `MAKEOVERRIDES' contains definitions for the
  138. variables defined on the command line; in the above example, its value
  139. is `CFLAGS=-O'.  If you *do not* want these variable de