home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 4 / FreshFish_May-June1994.bin / gnu / info / make.info-4 (.txt) < prev    next >
GNU Info File  |  1994-02-21  |  50KB  |  946 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: Environment,  Prev: Defining,  Up: Using Variables
  22. Variables from the Environment
  23. ==============================
  24.    Variables in `make' can come from the environment in which `make' is
  25. run.  Every environment variable that `make' sees when it starts up is
  26. transformed into a `make' variable with the same name and value.  But
  27. an explicit assignment in the makefile, or with a command argument,
  28. overrides the environment.  (If the `-e' flag is specified, then values
  29. from the environment override assignments in the makefile.  *Note
  30. Summary of Options: Options Summary.  But this is not recommended
  31. practice.)
  32.    Thus, by setting the variable `CFLAGS' in your environment, you can
  33. cause all C compilations in most makefiles to use the compiler switches
  34. you prefer.  This is safe for variables with standard or conventional
  35. meanings because you know that no makefile will use them for other
  36. things.  (But this is not totally reliable; some makefiles set `CFLAGS'
  37. explicitly and therefore are not affected by the value in the
  38. environment.)
  39.    When `make' is invoked recursively, variables defined in the outer
  40. invocation can be passed to inner invocations through the environment
  41. (*note Recursive Use of `make': Recursion.).  By default, only
  42. variables that came from the environment or the command line are passed
  43. to recursive invocations.  You can use the `export' directive to pass
  44. other variables.  *Note Communicating Variables to a Sub-`make':
  45. Variables/Recursion, for full details.
  46.    Other use of variables from the environment is not recommended.  It
  47. is not wise for makefiles to depend for their functioning on
  48. environment variables set up outside their control, since this would
  49. cause different users to get different results from the same makefile.
  50. This is against the whole purpose of most makefiles.
  51.    Such problems would be especially likely with the variable `SHELL',
  52. which is normally present in the environment to specify the user's
  53. choice of interactive shell.  It would be very undesirable for this
  54. choice to affect `make'.  So `make' ignores the environment value of
  55. `SHELL'.
  56. File: make.info,  Node: Conditionals,  Next: Functions,  Prev: Using Variables,  Up: Top
  57. Conditional Parts of Makefiles
  58. ******************************
  59.    A "conditional" causes part of a makefile to be obeyed or ignored
  60. depending on the values of variables.  Conditionals can compare the
  61. value of one variable to another, or the value of a variable to a
  62. constant string.  Conditionals control what `make' actually "sees" in
  63. the makefile, so they *cannot* be used to control shell commands at the
  64. time of execution.
  65. * Menu:
  66. * Conditional Example::         Example of a conditional
  67. * Conditional Syntax::          The syntax of conditionals.
  68. * Testing Flags::               Conditionals that test flags.
  69. File: make.info,  Node: Conditional Example,  Next: Conditional Syntax,  Up: Conditionals
  70. Example of a Conditional
  71. ========================
  72.    The following example of a conditional tells `make' to use one set
  73. of libraries if the `CC' variable is `gcc', and a different set of
  74. libraries otherwise.  It works by controlling which of two command
  75. lines will be used as the command for a rule.  The result is that
  76. `CC=gcc' as an argument to `make' changes not only which compiler is
  77. used but also which libraries are linked.
  78.      libs_for_gcc = -lgnu
  79.      normal_libs =
  80.      
  81.      foo: $(objects)
  82.      ifeq ($(CC),gcc)
  83.              $(CC) -o foo $(objects) $(libs_for_gcc)
  84.      else
  85.              $(CC) -o foo $(objects) $(normal_libs)
  86.      endif
  87.    This conditional uses three directives: one `ifeq', one `else' and
  88. one `endif'.
  89.    The `ifeq' directive begins the conditional, and specifies the
  90. condition.  It contains two arguments, separated by a comma and
  91. surrounded by parentheses.  Variable substitution is performed on both
  92. arguments and then they are compared.  The lines of the makefile
  93. following the `ifeq' are obeyed if the two arguments match; otherwise
  94. they are ignored.
  95.    The `else' directive causes the following lines to be obeyed if the
  96. previous conditional failed.  In the example above, this means that the
  97. second alternative linking command is used whenever the first
  98. alternative is not used.  It is optional to have an `else' in a
  99. conditional.
  100.    The `endif' directive ends the conditional.  Every conditional must
  101. end with an `endif'.  Unconditional makefile text follows.
  102.    As this example illustrates, conditionals work at the textual level:
  103. the lines of the conditional are treated as part of the makefile, or
  104. ignored, according to the condition.  This is why the larger syntactic
  105. units of the makefile, such as rules, may cross the beginning or the
  106. end of the conditional.
  107.    When the variable `CC' has the value `gcc', the above example has
  108. this effect:
  109.      foo: $(objects)
  110.              $(CC) -o foo $(objects) $(libs_for_gcc)
  111. When the variable `CC' has any other value, the effect is this:
  112.      foo: $(objects)
  113.              $(CC) -o foo $(objects) $(normal_libs)
  114.    Equivalent results can be obtained in another way by
  115. conditionalizing a variable assignment and then using the variable
  116. unconditionally:
  117.      libs_for_gcc = -lgnu
  118.      normal_libs =
  119.      
  120.      ifeq ($(CC),gcc)
  121.        libs=$(libs_for_gcc)
  122.      else
  123.        libs=$(normal_libs)
  124.      endif
  125.      
  126.      foo: $(objects)
  127.              $(CC) -o foo $(objects) $(libs)
  128. File: make.info,  Node: Conditional Syntax,  Next: Testing Flags,  Prev: Conditional Example,  Up: Conditionals
  129. Syntax of Conditionals
  130. ======================
  131.    The syntax of a simple conditional with no `else' is as follows:
  132.      CONDITIONAL-DIRECTIVE
  133.      TEXT-IF-TRUE
  134.      endif
  135. The TEXT-IF-TRUE may be any lines of text, to be considered as part of
  136. the makefile if the condition is true.  If the condition is false, no
  137. text is used instead.
  138.    The syntax of a complex conditional is as follows:
  139.      CONDITIONAL-DIRECTIVE
  140.      TEXT-IF-TRUE
  141.      else
  142.      TEXT-IF-FALSE
  143.      endif
  144. If the condition is true, TEXT-IF-TRUE is used; otherwise,
  145. TEXT-IF-FALSE is used instead.  The TEXT-IF-FALSE can be any number of
  146. lines of text.
  147.    The syntax of the CONDITIONAL-DIRECTIVE is the same whether the
  148. conditional is simple or complex.  There are four different directives
  149. that test different conditions.  Here is a table of them:
  150. `ifeq (ARG1, ARG2)'
  151. `ifeq 'ARG1' 'ARG2''
  152. `ifeq "ARG1" "ARG2"'
  153. `ifeq "ARG1" 'ARG2''
  154. `ifeq 'ARG1' "ARG2"'
  155.      Expand all variable references in ARG1 and ARG2 and compare them.
  156.      If they are identical, the TEXT-IF-TRUE is effective; otherwise,
  157.      the TEXT-IF-FALSE, if any, is effective.
  158.      Often you want to test if a variable has a non-empty value.  When
  159.      the value results from complex expansions of variables and
  160.      functions, expansions you would consider empty may actually
  161.      contain whitespace characters and thus are not seen as empty.
  162.      However, you can use the `strip' function (*note Text
  163.      Functions::.) to avoid interpreting whitespace as a non-empty
  164.      value.  For example:
  165.           ifeq ($(strip $(foo)),)
  166.           TEXT-IF-EMPTY
  167.