home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / make-3.75-bin.lha / info / make.info-3 (.txt) < prev    next >
GNU Info File  |  1996-10-12  |  51KB  |  924 lines

  1. This is Info file make.info, produced by Makeinfo-1.64 from the input
  2. file /ade-src/fsf/make/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.51, last updated 9 May 1996, of `The GNU Make
  7. Manual', for `make', Version 3.75 Beta.
  8.    Copyright (C) 1988, '89, '90, '91, '92, '93, '94, '95, '96
  9. Free Software 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: Parallel,  Next: Errors,  Prev: Execution,  Up: Commands
  22. Parallel Execution
  23. ==================
  24.    GNU `make' knows how to execute several commands at once.  Normally,
  25. `make' will execute only one command at a time, waiting for it to
  26. finish before executing the next.  However, the `-j' or `--jobs' option
  27. tells `make' to execute many commands simultaneously.
  28.    If the `-j' option is followed by an integer, this is the number of
  29. commands to execute at once; this is called the number of "job slots".
  30. If there is nothing looking like an integer after the `-j' option,
  31. there is no limit on the number of job slots.  The default number of job
  32. slots is one, which means serial execution (one thing at a time).
  33.    One unpleasant consequence of running several commands
  34. simultaneously is that output from all of the commands comes when the
  35. commands send it, so messages from different commands may be
  36. interspersed.
  37.    Another problem is that two processes cannot both take input from the
  38. same device; so to make sure that only one command tries to take input
  39. from the terminal at once, `make' will invalidate the standard input
  40. streams of all but one running command.  This means that attempting to
  41. read from standard input will usually be a fatal error (a `Broken pipe'
  42. signal) for most child processes if there are several.
  43.    It is unpredictable which command will have a valid standard input
  44. stream (which will come from the terminal, or wherever you redirect the
  45. standard input of `make').  The first command run will always get it
  46. first, and the first command started after that one finishes will get
  47. it next, and so on.
  48.    We will change how this aspect of `make' works if we find a better
  49. alternative.  In the mean time, you should not rely on any command using
  50. standard input at all if you are using the parallel execution feature;
  51. but if you are not using this feature, then standard input works
  52. normally in all commands.
  53.    If a command fails (is killed by a signal or exits with a nonzero
  54. status), and errors are not ignored for that command (*note Errors in
  55. Commands: Errors.), the remaining command lines to remake the same
  56. target will not be run.  If a command fails and the `-k' or
  57. `--keep-going' option was not given (*note Summary of Options: Options
  58. Summary.), `make' aborts execution.  If make terminates for any reason
  59. (including a signal) with child processes running, it waits for them to
  60. finish before actually exiting.
  61.    When the system is heavily loaded, you will probably want to run
  62. fewer jobs than when it is lightly loaded.  You can use the `-l' option
  63. to tell `make' to limit the number of jobs to run at once, based on the
  64. load average.  The `-l' or `--max-load' option is followed by a
  65. floating-point number.  For example,
  66.      -l 2.5
  67. will not let `make' start more than one job if the load average is
  68. above 2.5.  The `-l' option with no following number removes the load
  69. limit, if one was given with a previous `-l' option.
  70.    More precisely, when `make' goes to start up a job, and it already
  71. has at least one job running, it checks the current load average; if it
  72. is not lower than the limit given with `-l', `make' waits until the load
  73. average goes below that limit, or until all the other jobs finish.
  74.    By default, there is no load limit.
  75. File: make.info,  Node: Errors,  Next: Interrupts,  Prev: Parallel,  Up: Commands
  76. Errors in Commands
  77. ==================
  78.    After each shell command returns, `make' looks at its exit status.
  79. If the command completed successfully, the next command line is executed
  80. in a new shell; after the last command line is finished, the rule is
  81. finished.
  82.    If there is an error (the exit status is nonzero), `make' gives up on
  83. the current rule, and perhaps on all rules.
  84.    Sometimes the failure of a certain command does not indicate a
  85. problem.  For example, you may use the `mkdir' command to ensure that a
  86. directory exists.  If the directory already exists, `mkdir' will report
  87. an error, but you probably want `make' to continue regardless.
  88.    To ignore errors in a command line, write a `-' at the beginning of
  89. the line's text (after the initial tab).  The `-' is discarded before
  90. the command is passed to the shell for execution.
  91.    For example,
  92.      clean:
  93.              -rm -f *.o
  94. This causes `rm' to continue even if it is unable to remove a file.
  95.    When you run `make' with the `-i' or `--ignore-errors' flag, errors
  96. are ignored in all commands of all rules.  A rule in the makefile for
  97. the special target `.IGNORE' has the same effect, if there are no
  98. dependencies.  These ways of ignoring errors are obsolete because `-'
  99. is more flexible.
  100.    When errors are to be ignored, because of either a `-' or the `-i'
  101. flag, `make' treats an error return just like success, except that it
  102. prints out a message that tells you the status code the command exited
  103. with, and says that the error has been ignored.
  104.    When an error happens that `make' has not been told to ignore, it
  105. implies that the current target cannot be correctly remade, and neither
  106. can any other that depends on it either directly or indirectly.  No
  107. further commands will be executed for these targets, since their
  108. preconditions have not been achieved.
  109.    Normally `make' gives up immediately in this circumstance, returning
  110. a nonzero status.  However, if the `-k' or `--keep-going' flag is
  111. specified, `make' continues to consider the other dependencies of the
  112. pending targets, remaking them if necessary, before it gives up and
  113. returns nonzero status.  For example, after an error in compiling one
  114. object file, `make -k' will continue compiling other object files even
  115. though it already knows that linking them will be impossible.  *Note
  116. Summary of Options: Options Summary.
  117.    The usual behavior assumes that your purpose is to get the specified
  118. targets up to date; once `make' learns that this is impossible, it
  119. might as well report the failure immediately.  The `-k' option says
  120. that the real purpose is to test as many of the changes made in the
  121. program as possible, perhaps to find several independent problems so
  122. that you can correct them all before the next attempt to compile.  This
  123. is why Emacs' `compile' command passes the `-k' flag by default.
  124.    Usually when a command fails, if it has changed the target file at
  125. all, the file is corrupted and cannot be used--or at least it is not
  126. completely updated.  Yet the file's timestamp says that it is now up to
  127. date, so the next time `make' runs, it will not try to update that
  128. file.  The situation is just the same as when the command is killed by a
  129. signal; *note Interrupts::..  So generally the right thing to do is to
  130. delete the target file if the command fails after beginning to change
  131. the file.  `make' will do this if `.DELETE_ON_ERROR' appears as a
  132. target.  This is almost always what you want `make' to do, but it is
  133. not historical practice; so for compatibility, you must explicitly
  134. request it.
  135. File: make.info,  Node: Interrupts,  Next: Recursion,  Prev: Errors,  Up: Commands
  136. Interrupting or Killing `make'
  137. ==============================
  138.    If `make' gets a fatal signal while a command is executing, it may
  139. delete the target file that the command was supposed to update.  This is
  140. done if the target file's last-modification time has changed since
  141. `make' first checked it.
  142.    The purpose of deleting the target is to make sure that it is remade
  143. from scratch when `make' is next run.  Why is this?  Suppose you type
  144. `Ctrl-c' while a compiler is running, and it has begun to write an
  145. object file `foo.o'.  The `Ctrl-c' kills the compiler, resulting in an
  146. incomplete file whose last-modification time is newer than the source
  147. file `foo.c'.  But `make' also receives the `Ctrl-c' signal and deletes
  148. this incomplete file.  If `make' did not do this, the next invocation
  149. of `make' would think that `foo.o' did not require updating--resulting
  150. in a strange error message from the linker when it tries to link an
  151. object file half of which is missing.
  152.    You can prevent the deletion of a target file in this way by making
  153. the special target `.PRECIOUS' depend on it.  Before remaking a target,
  154. `make' checks to see whether it appears on the dependencies of
  155. `.PRECIOUS', and thereby decides whether the target should be deleted
  156. if a signal happens.  Some reasons why you might do this are that the
  157. target is updated in some atomic fashion, or exists only to record a
  158. modification-time (its contents do not matter), or must exist at all
  159. times to prevent other sorts of trouble.
  160. File: make.info,  Node: Recursion,  Next: Sequences,  Prev: Interrupts,  Up: Commands
  161. Recursive Use of `make'
  162. =======================
  163.    Recursive use of `make' means using `make' as a command in a
  164. makefile.  This technique is useful when you want separate makefiles for
  165. various subsystems that compose a larger system.  For example, suppose
  166. you have a subdirectory `subdir' which has its own makefile, and you
  167. would like the containing directory's makefile to run `make' on the
  168. subdirectory.  You can do it by writing this:
  169.      subsystem:
  170.              cd subdir; $(MAKE)
  171. or, equivalently, this (*note Summary of Options: Options Summary.):
  172.      subsystem:
  173.              $(MAKE) -C subdir
  174.    You can write recursive `make' commands just by copying this example,
  175. but there are many things to know about how they work and why, and about
  176. how the sub-`make' relates to the top-level `make'.
  177. * Menu:
  178. * MAKE Variable::               The special effects of using `$(MAKE)'.
  179. * Variables/Recursion::         How to communicate variables to a sub-`make'.
  180. * Options/Recursion::           How to communicate options to a sub-`make'.
  181. * -w Option::                   How the `-w' or `--print-directory' option
  182.                                  helps debug use of recursive `make' commands.
  183. File: make.info,  Node: MAKE Variable,  Next: Variables/Recursion,  Up: Recursion
  184. How the `MAKE' Variable Works
  185. -----------------------------
  186.    Recursive `make' commands should always use the variable `MAKE', not
  187. the explicit command name `make', as shown here:
  188.      subsystem:
  189.              cd subdir; $(MAKE)
  190.    The value of this variable is the file name with which `make' was
  191. invoked.  If this file name was `/bin/make', then the command executed
  192. is `cd subdir; /bin/make'.  If you use a special version of `make' to
  193. run the top-level makefile, the same special version will be executed
  194. for recursive invocations.
  195.    As a special feature, using the variable `MAKE' in the commands of a
  196. rule alters the effects of the `-t' (`--touch'), `-n' (`--just-print'),
  197. or `-q' (`--question') option.  Using the `MAKE' variable has the same
  198. effect as using a `+' character at the beginning of the command line.
  199. *Note Instead of Executing the Commands: Instead of Execution.
  200.    Consider the command `make -t' in the above example.  (The `-t'
  201. option marks targets as up to date without actually running any
  202. commands; see *Note Instead of Execution::.)  Following the usual
  203. definition of `-t', a `make -t' command in the example would create a
  204. file named `subsystem' and do nothing else.  What you really want it to
  205. do is run `cd subdir; make -t'; but that would require executing the
  206. command, and `-t' says not to execute commands.
  207.    The special feature makes this do what you want: whenever a command
  208. line of a rule contains the variable `MAKE', the flags `-t', `-n' and
  209. `-q' do not apply to that line.  Command lines containing `MAKE' are
  210. executed normally despite the presence of a flag that causes most
  211. commands not to be run.  The usual `MAKEFLAGS' mechanism passes the
  212. flags to the sub-`make' (*note Communicating Options to a Sub-`make':
  213. Options/Recursion.), so your request to touch the files, or print the
  214. commands, is propagated to the subsystem.
  215. File: make.info,  Node: Variables/Recursion,  Next: Options/Recursion,  Prev: MAKE Variable,  Up: Recursion
  216. Communicating Variables to a Sub-`make'
  217. ---------------------------------------
  218.    Variable values of the top-level `make' can be passed to the
  219. sub-`make' through the environment by explicit request.  These
  220. variables are defined in the sub-`make' as defaults, but do not
  221. override what is specified in the makefile used by the sub-`make'
  222. makefile unless you use the `-e' switch (*note Summary of Options:
  223. Options Summary.).
  224.    To pass down, or "export", a variable, `make' adds the variable and
  225. its value to the environment for running each command.  The sub-`make',
  226. in turn, uses the environment to initialize its table of variable
  227. values.  *Note Variables from the Environment: Environment.
  228.    Except by explicit request, `make' exports a variable only if it is
  229. either defined in the environment initially or set on the command line,
  230. and if its name consists only of letters, numbers, and underscores.
  231. Some shells cannot cope with environment variable names consisting of
  232. characters other than letters, numbers, and underscores.
  233.    The special variables `SHELL' and `MAKEFLAGS' are always exported
  234. (unless you unexport them).  `MAKEFILES' is exported if you set it to
  235. anything.
  236.    `make' automatically passes down variable values that were defined
  237. on the command line, by putting them in the `MAKEFLAGS' variable.
  238. *Note Options/Recursion::.
  239.    Variables are *not* normally passed down if they were created by
  240. default by `make' (*note Variables Used by Implicit Rules: Implicit
  241. Variables.).  The sub-`make' will define these for itself.
  242.    If you want to export specific variables to a sub-`make', use the
  243. `export' directive, like this:
  244.      export VARIABLE ...
  245. If you want to *prevent* a variable from being exported, use the
  246. `unexport' directive, like this:
  247.      unexport VARIABLE ...
  248. As a convenience, you can define a variable and export it at the same
  249. time by doing:
  250.      export VARIABLE = value
  251. has the same result as:
  252.      VARIABLE = value
  253.      export VARIABLE
  254.      export VARIABLE := value
  255. has the same result as:
  256.      VARIABLE := value
  257.      export VARIABLE
  258.    Likewise,
  259.      export VARIABLE += value
  260. is just like:
  261.      VARIABLE += value
  262.      export VARIABLE
  263. *Note Appending More Text to Variables: Appending.
  264.    You may notice that the `export' and `unexport' directives work in
  265. `make' in the same way they work in the shell, `sh'.
  266.    If you want all variables to be exported by default, you can use
  267. `export' by itself:
  268.      export
  269. This tells `make' that variables which are not explicitly mentioned in
  270. an `export' or `unexport' directive should be exported.  Any variable
  271. given in an `unexport' directive will still *not* be exported.  If you
  272. use `export' by itself to export variables by default, variables whose
  273. names contain characters other than alphanumerics and underscores will
  274. not be exported unless specifically mentioned in an `export' directive.
  275.    The behavior elicited by an `export' directive by itself was the
  276. default in older versions of GNU `make'.  If your makefiles depend on
  277. this behavior and you want to be compatible with old versions of
  278. `make', you can write a rule for the special target
  279. `.EXPORT_ALL_VARIABLES' instead of using the `export' directive.  This
  280. will be ignored by old `make's, while the `export' directive will cause
  281. a syntax error.
  282.    Likewise, you can use `unexport' by itself to tell `make' *not* to
  283. export variables by default.  Since this is the default behavior, you
  284. would only need to do this if `export' had been used by itself earlier
  285. (in an included makefile, perhaps).  You *cannot* use `export' and
  286. `unexport' by themselves to have variables exported for some commands
  287. and not for others.  The last `export' or `unexport' directive that
  288. appears by itself determines the behavior for the entire run of `make'.
  289.    As a special feature, the variable `MAKELEVEL' is changed when it is
  290. passed down from level to level.  This variable's value is a string
  291. which is the depth of the level as a decimal number.  The value is `0'
  292. for the top-level `make'; `1' for a sub-`make', `2' for a
  293. sub-sub-`make', and so on.  The incrementation happens when `make' sets
  294. up the environment for a command.
  295.    The main use of `MAKELEVEL' is to test it in a conditional directive
  296. (*note Conditional Parts of Makefiles: Conditionals.); this way you can
  297. write a makefile that behaves one way if run recursively and another
  298. way if run directly by you.
  299.    You can use the variable `MAKEFILES' to cause all sub-`make'
  300. commands to use additional makefiles.  The value of `MAKEFILES' is a
  301. whitespace-separated list of file names.  This variable, if defined in
  302. the outer-level makefile, is passed down through the environment; then
  303. it serves as a list of extra makefiles for the sub-`make' to read
  304. before the usual or specified ones.  *Note The Variable `MAKEFILES':
  305. MAKEFILES Variable.
  306. File: make.info,  Node: Options/Recursion,  Next: -w Option,  Prev: Variables/Recursion,  Up: Recursion
  307. Communicating Options to a Sub-`make'
  308. -------------------------------------
  309.    Flags such as `-s' and `-k' are passed automatically to the
  310. sub-`make' through the variable `MAKEFLAGS'.  This variable is set up
  311. automatically by `make' to contain the flag letters that `make'
  312. received.  Thus, if you do `make -ks' then `MAKEFLAGS' gets the value
  313. `ks'.
  314.    As a consequence, every sub-`make' gets a value for `MAKEFLAGS' in
  315. its environment.  In response, it takes the flags from that value and
  316. processes them as if they had been given as arguments.  *Note Summary
  317. of Options: Options Summary.
  318.    Likewise variables defined on the command line are passed to the
  319. sub-`make' through `MAKEFLAGS'.  Words in the value of `MAKEFLAGS' that
  320. contain `=', `make' treats as variable definitions just as if they
  321. appeared on the command line.  *Note Overriding Variables: Overriding.
  322.    The options `-C', `-f', `-o', and `-W' are not put into `MAKEFLAGS';
  323. these options are not passed down.
  324.    The `-j' option is a special case (*note Parallel Execution:
  325. Parallel.).  If you set it to some numeric value, `-j 1' is always put
  326. into `MAKEFLAGS' instead of the value you specified.  This is because if
  327. the `-j' option were passed down to sub-`make's, you would get many
  328. more jobs running in parallel than you asked for.  If you give `-j'
  329. with no numeric argument, meaning to run as many jobs as possible in
  330. parallel, this is passed down, since multiple infinities are no more
  331. than one.
  332.    If you do not want to pass the other flags down, you must change the
  333. value of `MAKEFLAGS', like this:
  334.      subsystem:
  335.              cd subdir; $(MAKE) MAKEFLAGS=
  336.    The command line variable definitions really appear in the variable
  337. `MAKEOVERRIDES', and `MAKEFLAGS' contains a reference to this variable.
  338. If you do want to pass flags down normally, but don't want to pass
  339. down the command line variable definitions, you can reset
  340. `MAKEOVERRIDES' to empty, like this:
  341.      MAKEOVERRIDES =
  342. This is not usually useful to do.  However, some systems have a small
  343. fixed limit on the size of the environment, and putting so much
  344. information in into the value of `MAKEFLAGS' can exceed it.  If you see
  345. the error message `Arg list too long', this may be the problem.  (For
  346. strict compliance with POSIX.2, changing `MAKEOVERRIDES' does not
  347. affect `MAKEFLAGS' if the special target `.POSIX' appears in the
  348. makefile.  You probably do not care about this.)
  349.    A similar variable `MFLAGS' exists also, for historical
  350. compatibility.  It has the same value as `MAKEFLAGS' except that it
  351. does not contain the command line variable definitions, and it always
  352. begins with a hyphen unless it is empty (`MAKEFLAGS' begins with a
  353. hyphen only when it begins with an option that has no single-letter
  354. version, such as `--warn-undefined-variables').  `MFLAGS' was
  355. traditionally used explicitly in the recursive `make' command, like
  356. this:
  357.      subsystem:
  358.              cd subdir; $(MAKE) $(MFLAGS)
  359. but now `MAKEFLAGS' makes this usage redundant.  If you want your
  360. makefiles to be compatible with old `make' programs, use this
  361. technique; it will work fine with more modern `make' versions too.
  362.    The `MAKEFLAGS' variable can also be useful if you want to have
  363. certain options, such as `-k' (*note Summary of Options: Options
  364. Summary.), set each time you run `make'.  You simply put a value for
  365. `MAKEFLAGS' in your environment.  You can also set `MAKEFLAGS' in a
  366. makefile, to specify additional flags that should also be in effect for
  367. that makefile.  (Note that you cannot use `MFLAGS' this way.  That
  368. variable is set only for compatibility; `make' does not interpret a
  369. value you set for it in any way.)
  370.    When `make' interprets the value of `MAKEFLAGS' (either from the
  371. environment or from a makefile), it first prepends a hyphen if the value
  372. does not already begin with one.  Then it chops the value into words
  373. separated by blanks, and parses these words as if they were options
  374. given on the command line (except that `-C', `-f', `-h', `-o', `-W',
  375. and their long-named versions are ignored; and there is no error for an
  376. invalid option).
  377.    If you do put `MAKEFLAGS' in your environment, you should be sure not
  378. to include any options that will drastically affect the actions of
  379. `make' and undermine the purpose of makefiles and of `make' itself.
  380. For instance, the `-t', `-n', and `-q' options, if put in one of these
  381. variables, could have disastrous consequences and would certainly have
  382. at least surprising and probably annoying effects.
  383. File: make.info,  Node: -w Option,  Prev: Options/Recursion,  Up: Recursion
  384. The `--print-directory' Option
  385. ------------------------------
  386.    If you use several levels of recursive `make' invocations, the `-w'
  387. or `--print-directory' option can make the output a lot easier to
  388. understand by showing each directory as `make' starts processing it and
  389. as `make' finishes processing it.  For example, if `make -w' is run in
  390. the directory `/u/gnu/make', `make' will print a line of the form:
  391.      make: Entering directory `/u/gnu/make'.
  392. before doing anything else, and a line of the form:
  393.      make: Leaving directory `/u/gnu/make'.
  394. when processing is completed.
  395.    Normally, you do not need to specify this option because `make' does
  396. it for you: `-w' is turned on automatically when you use the `-C'
  397. option, and in sub-`make's.  `make' will not automatically turn on `-w'
  398. if you also use `-s', which says to be silent, or if you use
  399. `--no-print-directory' to explicitly disable it.
  400. File: make.info,  Node: Sequences,  Next: Empty Commands,  Prev: Recursion,  Up: Commands
  401. Defining Canned Command Sequences
  402. =================================
  403.    When the same sequence of commands is useful in making various
  404. targets, you can define it as a canned sequence with the `define'
  405. directive, and refer to the canned sequence from the rules for those
  406. targets.  The canned sequence is actually a variable, so the name must
  407. not conflict with other variable names.
  408.    Here is an example of defining a canned sequence of commands:
  409.      define run-yacc
  410.      yacc $(firstword $^)
  411.      mv y.tab.c $@
  412.      endef
  413. Here `run-yacc' is the name of the variable being defined; `endef'
  414. marks the end of the definition; the lines in between are the commands.
  415. The `define' directive does not expand variable references and
  416. function calls in the canned sequence; the `$' characters, parentheses,
  417. variable names, and so on, all become part of the value of the variable
  418. you are defining.  *Note Defining Variables Verbatim: Defining, for a
  419. complete explanation of `define'.
  420.    The first command in this example runs Yacc on the first dependency
  421. of whichever rule uses the canned sequence.  The output file from Yacc
  422. is always named `y.tab.c'.  The second command moves the output to the
  423. rule's target file name.
  424.    To use the canned sequence, substitute the variable into the
  425. commands of a rule.  You can substitute it like any other variable
  426. (*note Basics of Variable References: Reference.).  Because variables
  427. defined by `define' are recursively expanded variables, all the
  428. variable references you wrote inside the `define' are expanded now.
  429. For example:
  430.      foo.c : foo.y
  431.              $(run-yacc)
  432. `foo.y' will be substituted for the variable `$^' when it occurs in
  433. `run-yacc''s value, and `foo.c' for `$@'.
  434.    This is a realistic example, but this particular one is not needed in
  435. practice because `make' has an implicit rule to figure out these
  436. commands based on the file names involved (*note Using Implicit Rules:
  437. Implicit Rules.).
  438.    In command execution, each line of a canned sequence is treated just
  439. as if the line appeared on its own in the rule, preceded by a tab.  In
  440. particular, `make' invokes a separate subshell for each line.  You can
  441. use the special prefix characters that affect command lines (`@', `-',
  442. and `+') on each line of a canned sequence.  *Note Writing the Commands
  443. in Rules: Commands.  For example, using this canned sequence:
  444.      define frobnicate
  445.      @echo "frobnicating target $@"
  446.      frob-step-1 $< -o $@-step-1
  447.      frob-step-2 $@-step-1 -o $@
  448.      endef
  449. `make' will not echo the first line, the `echo' command.  But it *will*
  450. echo the following two command lines.
  451.    On the other hand, prefix characters on the command line that refers
  452. to a canned sequence apply to every line in the sequence.  So the rule:
  453.      frob.out: frob.in
  454.          @$(frobnicate)
  455. does not echo *any* commands.  (*Note Command Echoing: Echoing, for a
  456. full explanation of `@'.)
  457. File: make.info,  Node: Empty Commands,  Prev: Sequences,  Up: Commands
  458. Using Empty Commands
  459. ====================
  460.    It is sometimes useful to define commands which do nothing.  This is
  461. done simply by giving a command that consists of nothing but
  462. whitespace.  For example:
  463.      target: ;
  464. defines an empty command string for `target'.  You could also use a
  465. line beginning with a tab character to define an empty command string,
  466. but this would be confusing because such a line looks empty.
  467.    You may be wondering why you would want to define a command string
  468. that does nothing.  The only reason this is useful is to prevent a
  469. target from getting implicit commands (from implicit rules or the
  470. `.DEFAULT' special target; *note Implicit Rules::. and *note Defining
  471. Last-Resort Default Rules: Last Resort.).
  472.    You may be inclined to define empty command strings for targets that
  473. are not actual files, but only exist so that their dependencies can be
  474. remade.  However, this is not the best way to do that, because the
  475. dependencies may not be remade properly if the target file actually
  476. does exist.  *Note Phony Targets: Phony Targets, for a better way to do
  477. this.
  478. File: make.info,  Node: Using Variables,  Next: Conditionals,  Prev: Commands,  Up: Top
  479. How to Use Variables
  480. ********************
  481.    A "variable" is a name defined in a makefile to represent a string
  482. of text, called the variable's "value".  These values are substituted
  483. by explicit request into targets, dependencies, commands, and other
  484. parts of the makefile.  (In some other versions of `make', variables
  485. are called "macros".)
  486.    Variables and functions in all parts of a makefile are expanded when
  487. read, except for the shell commands in rules, the right-hand sides of
  488. variable definitions using `=', and the bodies of variable definitions
  489. using the `define' directive.
  490.    Variables can represent lists of file names, options to pass to
  491. compilers, programs to run, directories to look in for source files,
  492. directories to write output in, or anything else you can imagine.
  493.    A variable name may be any sequence of characters not containing `:',
  494. `#', `=', or leading or trailing whitespace.  However, variable names
  495. containing characters other than letters, numbers, and underscores
  496. should be avoided, as they may be given special meanings in the future,
  497. and with some shells they cannot be passed through the environment to a
  498. sub-`make' (*note Communicating Variables to a Sub-`make':
  499. Variables/Recursion.).
  500.    Variable names are case-sensitive.  The names `foo', `FOO', and
  501. `Foo' all refer to different variables.
  502.    It is traditional to use upper case letters in variable names, but we
  503. recommend using lower case letters for variable names that serve
  504. internal purposes in the makefile, and reserving upper case for
  505. parameters that control implicit rules or for parameters that the user
  506. should override with command options (*note Overriding Variables:
  507. Overriding.).
  508.    A few variables have names that are a single punctuation character or
  509. just a few characters.  These are the "automatic variables", and they
  510. have particular specialized uses.  *Note Automatic Variables: Automatic.
  511. * Menu:
  512. * Reference::                   How to use the value of a variable.
  513. * Flavors::                     Variables come in two flavors.
  514. * Advanced::                    Advanced features for referencing a variable.
  515. * Values::                      All the ways variables get their values.
  516. * Setting::                     How to set a variable in the makefile.
  517. * Appending::                   How to append more text to the old value
  518.                                   of a variable.
  519. * Override Directive::          How to set a variable in the makefile even if
  520.                                   the user has set it with a command argument.
  521. * Defining::                    An alternate way to set a variable
  522.                                   to a verbatim string.
  523. * Environment::                 Variable values can come from the environment.
  524. * Automatic::                   Some special variables have predefined
  525.                                   meanings for use with implicit rules.
  526. File: make.info,  Node: Reference,  Next: Flavors,  Up: Using Variables
  527. Basics of Variable References
  528. =============================
  529.    To substitute a variable's value, write a dollar sign followed by
  530. the name of the variable in parentheses or braces: either `$(foo)' or
  531. `${foo}' is a valid reference to the variable `foo'.  This special
  532. significance of `$' is why you must write `$$' to have the effect of a
  533. single dollar sign in a file name or command.
  534.    Variable references can be used in any context: targets,
  535. dependencies, commands, most directives, and new variable values.  Here
  536. is an example of a common case, where a variable holds the names of all
  537. the object files in a program:
  538.      objects = program.o foo.o utils.o
  539.      program : $(objects)
  540.              cc -o program $(objects)
  541.      
  542.      $(objects) : defs.h
  543.    Variable references work by strict textual substitution.  Thus, the
  544.      foo = c
  545.      prog.o : prog.$(foo)
  546.              $(foo)$(foo) -$(foo) prog.$(foo)
  547. could be used to compile a C program `prog.c'.  Since spaces before the
  548. variable value are ignored in variable assignments, the value of `foo'
  549. is precisely `c'.  (Don't actually write your makefiles this way!)
  550.    A dollar sign followed by a character other than a dollar sign,
  551. open-parenthesis or open-brace treats that single character as the
  552. variable name.  Thus, you could reference the variable `x' with `$x'.
  553. However, this practice is strongly discouraged, except in the case of
  554. the automatic variables (*note Automatic Variables: Automatic.).
  555. File: make.info,  Node: Flavors,  Next: Advanced,  Prev: Reference,  Up: Using Variables
  556. The Two Flavors of Variables
  557. ============================
  558.    There are two ways that a variable in GNU `make' can have a value;
  559. we call them the two "flavors" of variables.  The two flavors are
  560. distinguished in how they are defined and in what they do when expanded.
  561.    The first flavor of variable is a "recursively expanded" variable.
  562. Variables of this sort are defined by lines using `=' (*note Setting
  563. Variables: Setting.) or by the `define' directive (*note Defining
  564. Variables Verbatim: Defining.).  The value you specify is installed
  565. verbatim; if it contains references to other variables, these
  566. references are expanded whenever this variable is substituted (in the
  567. course of expanding some other string).  When this happens, it is
  568. called "recursive expansion".
  569.    For example,
  570.      foo = $(bar)
  571.      bar = $(ugh)
  572.      ugh = Huh?
  573.      
  574.      all:;echo $(foo)
  575. will echo `Huh?': `$(foo)' expands to `$(bar)' which expands to
  576. `$(ugh)' which finally expands to `Huh?'.
  577.    This flavor of variable is the only sort supported by other versions
  578. of `make'.  It has its advantages and its disadvantages.  An advantage
  579. (most would say) is that:
  580.      CFLAGS = $(include_dirs) -O
  581.      include_dirs = -Ifoo -Ibar
  582. will do what was intended: when `CFLAGS' is expanded in a command, it
  583. will expand to `-Ifoo -Ibar -O'.  A major disadvantage is that you
  584. cannot append something on the end of a variable, as in
  585.      CFLAGS = $(CFLAGS) -O
  586. because it will cause an infinite loop in the variable expansion.
  587. (Actually `make' detects the infinite loop and reports an error.)
  588.    Another disadvantage is that any functions (*note Functions for
  589. Transforming Text: Functions.) referenced in the definition will be
  590. executed every time the variable is expanded.  This makes `make' run
  591. slower; worse, it causes the `wildcard' and `shell' functions to give
  592. unpredictable results because you cannot easily control when they are
  593. called, or even how many times.
  594.    To avoid all the problems and inconveniences of recursively expanded
  595. variables, there is another flavor: simply expanded variables.
  596.    "Simply expanded variables" are defined by lines using `:=' (*note
  597. Setting Variables: Setting.).  The value of a simply expanded variable
  598. is scanned once and for all, expanding any references to other
  599. variables and functions, when the variable is defined.  The actual
  600. value of the simply expanded variable is the result of expanding the
  601. text that you write.  It does not contain any references to other
  602. variables; it contains their values *as of the time this variable was
  603. defined*.  Therefore,
  604.      x := foo
  605.      y := $(x) bar
  606.      x := later
  607. is equivalent to
  608.      y := foo bar
  609.      x := later
  610.    When a simply expanded variable is referenced, its value is
  611. substituted verbatim.
  612.    Here is a somewhat more complicated example, illustrating the use of
  613. `:=' in conjunction with the `shell' function.  (*Note The `shell'
  614. Function: Shell Function.)  This example also shows use of the variable
  615. `MAKELEVEL', which is changed when it is passed down from level to
  616. level.  (*Note Communicating Variables to a Sub-`make':
  617. Variables/Recursion, for information about `MAKELEVEL'.)
  618.      ifeq (0,${MAKELEVEL})
  619.      cur-dir   := $(shell pwd)
  620.      whoami    := $(shell whoami)
  621.      host-type := $(shell arch)
  622.      MAKE := ${MAKE} host-type=${host-type} whoami=${whoami}
  623.      endif
  624. An advantage of this use of `:=' is that a typical `descend into a
  625. directory' command then looks like this:
  626.      ${subdirs}:
  627.            ${MAKE} cur-dir=${cur-dir}/$@ -C $@ all
  628.    Simply expanded variables generally make complicated makefile
  629. programming more predictable because they work like variables in most
  630. programming languages.  They allow you to redefine a variable using its
  631. own value (or its value processed in some way by one of the expansion
  632. functions) and to use the expansion functions much more efficiently
  633. (*note Functions for Transforming Text: Functions.).
  634.    You can also use them to introduce controlled leading whitespace into
  635. variable values.  Leading whitespace characters are discarded from your
  636. input before substitution of variable references and function calls;
  637. this means you can include leading spaces in a variable value by
  638. protecting them with variable references, like this:
  639.      nullstring :=
  640.      space := $(nullstring) # end of the line
  641. Here the value of the variable `space' is precisely one space.  The
  642. comment `# end of the line' is included here just for clarity.  Since
  643. trailing space characters are *not* stripped from variable values, just
  644. a space at the end of the line would have the same effect (but be
  645. rather hard to read).  If you put whitespace at the end of a variable
  646. value, it is a good idea to put a comment like that at the end of the
  647. line to make your intent clear.  Conversely, if you do *not* want any
  648. whitespace characters at the end of your variable value, you must
  649. remember not to put a random comment on the end of the line after some
  650. whitespace, such as this:
  651.      dir := /foo/bar    # directory to put the frobs in
  652. Here the value of the variable `dir' is `/foo/bar    ' (with four
  653. trailing spaces), which was probably not the intention.  (Imagine
  654. something like `$(dir)/file' with this definition!)
  655. File: make.info,  Node: Advanced,  Next: Values,  Prev: Flavors,  Up: Using Variables
  656. Advanced Features for Reference to Variables
  657. ============================================
  658.    This section describes some advanced features you can use to
  659. reference variables in more flexible ways.
  660. * Menu:
  661. * Substitution Refs::           Referencing a variable with
  662.                                   substitutions on the value.
  663. * Computed Names::              Computing the name of the variable to refer to.
  664. File: make.info,  Node: Substitution Refs,  Next: Computed Names,  Up: Advanced
  665. Substitution References
  666. -----------------------
  667.    A "substitution reference" substitutes the value of a variable with
  668. alterations that you specify.  It has the form `$(VAR:A=B)' (or
  669. `${VAR:A=B}') and its meaning is to take the value of the variable VAR,
  670. replace every A at the end of a word with B in that value, and
  671. substitute the resulting string.
  672.    When we say "at the end of a word", we mean that A must appear
  673. either followed by whitespace or at the end of the value in order to be
  674. replaced; other occurrences of A in the value are unaltered.  For
  675. example:
  676.      foo := a.o b.o c.o
  677.      bar := $(foo:.o=.c)
  678. sets `bar' to `a.c b.c c.c'.  *Note Setting Variables: Setting.
  679.    A substitution reference is actually an abbreviation for use of the
  680. `patsubst' expansion function (*note Functions for String Substitution
  681. and Analysis: Text Functions.).  We provide substitution references as
  682. well as `patsubst' for compatibility with other implementations of
  683. `make'.
  684.    Another type of substitution reference lets you use the full power of
  685. the `patsubst' function.  It has the same form `$(VAR:A=B)' described
  686. above, except that now A must contain a single `%' character.  This
  687. case is equivalent to `$(patsubst A,B,$(VAR))'.  *Note Functions for
  688. String Substitution and Analysis: Text Functions, for a description of
  689. the `patsubst' function.
  690. For example:
  691.      foo := a.o b.o c.o
  692.      bar := $(foo:%.o=%.c)
  693. sets `bar' to `a.c b.c c.c'.
  694. File: make.info,  Node: Computed Names,  Prev: Substitution Refs,  Up: Advanced
  695. Computed Variable Names
  696. -----------------------
  697.    Computed variable names are a complicated concept needed only for
  698. sophisticated makefile programming.  For most purposes you need not
  699. consider them, except to know that making a variable with a dollar sign
  700. in its name might have strange results.  However, if you are the type
  701. that wants to understand everything, or you are actually interested in
  702. what they do, read on.
  703.    Variables may be referenced inside the name of a variable.  This is
  704. called a "computed variable name" or a "nested variable reference".
  705. For example,
  706.      x = y
  707.      y = z
  708.      a := $($(x))
  709. defines `a' as `z': the `$(x)' inside `$($(x))' expands to `y', so
  710. `$($(x))' expands to `$(y)' which in turn expands to `z'.  Here the
  711. name of the variable to reference is not stated explicitly; it is
  712. computed by expansion of `$(x)'.  The reference `$(x)' here is nested
  713. within the outer variable reference.
  714.    The previous example shows two levels of nesting, but any number of
  715. levels is possible.  For example, here are three levels:
  716.      x = y
  717.      y = z
  718.      z = u
  719.      a := $($($(x)))
  720. Here the innermost `$(x)' expands to `y', so `$($(x))' expands to
  721. `$(y)' which in turn expands to `z'; now we have `$(z)', which becomes
  722.    References to recursively-expanded variables within a variable name
  723. are reexpanded in the usual fashion.  For example:
  724.      x = $(y)
  725.      y = z
  726.      z = Hello
  727.      a := $($(x))
  728. defines `a' as `Hello': `$($(x))' becomes `$($(y))' which becomes
  729. `$(z)' which becomes `Hello'.
  730.    Nested variable references can also contain modified references and
  731. function invocations (*note Functions for Transforming Text:
  732. Functions.), just like any other reference.  For example, using the
  733. `subst' function (*note Functions for String Substitution and Analysis:
  734. Text Functions.):
  735.      x = variable1
  736.      variable2 := Hello
  737.      y = $(subst 1,2,$(x))
  738.      z = y
  739.      a := $($($(z)))
  740. eventually defines `a' as `Hello'.  It is doubtful that anyone would
  741. ever want to write a nested reference as convoluted as this one, but it
  742. works: `$($($(z)))' expands to `$($(y))' which becomes `$($(subst
  743. 1,2,$(x)))'.  This gets the value `variable1' from `x' and changes it
  744. by substitution to `variable2', so that the entire string becomes
  745. `$(variable2)', a simple variable reference whose value is `Hello'.
  746.    A computed variable name need not consist entirely of a single
  747. variable reference.  It can contain several variable references, as
  748. well as some invariant text.  For example,
  749.      a_dirs := dira dirb
  750.      1_dirs := dir1 dir2
  751.      
  752.      a_files := filea fileb
  753.      1_files := file1 file2
  754.      
  755.      ifeq "$(use_a)" "yes"
  756.      a1 := a
  757.      else
  758.      a1 := 1
  759.      endif
  760.      
  761.      ifeq "$(use_dirs)" "yes"
  762.      df := dirs
  763.      else
  764.      df := files
  765.      endif
  766.      
  767.      dirs := $($(a1)_$(df))
  768. will give `dirs' the same value as `a_dirs', `1_dirs', `a_files' or
  769. `1_files' depending on the settings of `use_a' and `use_dirs'.
  770.    Computed variable names can also be used in substitution references:
  771.      a_objects := a.o b.o c.o
  772.      1_objects := 1.o 2.o 3.o
  773.      
  774.      sources := $($(a1)_objects:.o=.c)
  775. defines `sources' as either `a.c b.c c.c' or `1.c 2.c 3.c', depending
  776. on the value of `a1'.
  777.    The only restriction on this sort of use of nested variable
  778. references is that they cannot specify part of the name of a function
  779. to be called.  This is because the test for a recognized function name
  780. is done before the expansion of nested references.  For example,
  781.      ifdef do_sort
  782.      func := sort
  783.      else
  784.      func := strip
  785.      endif
  786.      
  787.      bar := a d b g q c
  788.      
  789.      foo := $($(func) $(bar))
  790. attempts to give `foo' the value of the variable `sort a d b g q c' or
  791. `strip a d b g q c', rather than giving `a d b g q c' as the argument
  792. to either the `sort' or the `strip' function.  This restriction could
  793. be removed in the future if that change is shown to be a good idea.
  794.    You can also use computed variable names in the left-hand side of a
  795. variable assignment, or in a `define' directive, as in:
  796.      dir = foo
  797.      $(dir)_sources := $(wildcard $(dir)/*.c)
  798.      define $(dir)_print
  799.      lpr $($(dir)_sources)
  800.      endef
  801. This example defines the variables `dir', `foo_sources', and
  802. `foo_print'.
  803.    Note that "nested variable references" are quite different from
  804. "recursively expanded variables" (*note The Two Flavors of Variables:
  805. Flavors.), though both are used together in complex ways when doing
  806. makefile programming.
  807. File: make.info,  Node: Values,  Next: Setting,  Prev: Advanced,  Up: Using Variables
  808. How Variables Get Their Values
  809. ==============================
  810.    Variables can get values in several different ways:
  811.    * You can specify an overriding value when you run `make'.  *Note
  812.      Overriding Variables: Overriding.
  813.    * You can specify a value in the makefile, either with an assignment
  814.      (*note Setting Variables: Setting.) or with a verbatim definition
  815.      (*note Defining Variables Verbatim: Defining.).
  816.    * Variables in the environment become `make' variables.  *Note
  817.      Variables from the Environment: Environment.
  818.    * Several "automatic" variables are given new values for each rule.
  819.      Each of these has a single conventional use.  *Note Automatic
  820.      Variables: Automatic.
  821.    * Several variables have constant initial values.  *Note Variables
  822.      Used by Implicit Rules: Implicit Variables.
  823. File: make.info,  Node: Setting,  Next: Appending,  Prev: Values,  Up: Using Variables
  824. Setting Variables
  825. =================
  826.    To set a variable from the makefile, write a line starting with the
  827. variable name followed by `=' or `:='.  Whatever follows the `=' or
  828. `:=' on the line becomes the value.  For example,
  829.      objects = main.o foo.o bar.o utils.o
  830. defines a variable named `objects'.  Whitespace around the variable
  831. name and immediately after the `=' is ignored.
  832.    Variables defined with `=' are "recursively expanded" variables.
  833. Variables defined with `:=' are "simply expanded" variables; these
  834. definitions can contain variable references which will be expanded
  835. before the definition is made.  *Note The Two Flavors of Variables:
  836. Flavors.
  837.    The variable name may contain function and variable references, which
  838. are expanded when the line is read to find the actual variable name to
  839.    There is no limit on the length of the value of a variable except the
  840. amount of swapping space on the computer.  When a variable definition is
  841. long, it is a good idea to break it into several lines by inserting
  842. backslash-newline at convenient places in the definition.  This will not
  843. affect the functioning of `make', but it will make the makefile easier
  844. to read.
  845.    Most variable names are considered to have the empty string as a
  846. value if you have never set them.  Several variables have built-in
  847. initial values that are not empty, but you can set them in the usual
  848. ways (*note Variables Used by Implicit Rules: Implicit Variables.).
  849. Several special variables are set automatically to a new value for each
  850. rule; these are called the "automatic" variables (*note Automatic
  851. Variables: Automatic.).
  852. File: make.info,  Node: Appending,  Next: Override Directive,  Prev: Setting,  Up: Using Variables
  853. Appending More Text to Variables
  854. ================================
  855.    Often it is useful to add more text to the value of a variable
  856. already defined.  You do this with a line containing `+=', like this:
  857.      objects += another.o
  858. This takes the value of the variable `objects', and adds the text
  859. `another.o' to it (preceded by a single space).  Thus:
  860.      objects = main.o foo.o bar.o utils.o
  861.      objects += another.o
  862. sets `objects' to `main.o foo.o bar.o utils.o another.o'.
  863.    Using `+=' is similar to:
  864.      objects = main.o foo.o bar.o utils.o
  865.      objects := $(objects) another.o
  866. but differs in ways that become important when you use more complex
  867. values.
  868.    When the variable in question has not been defined before, `+=' acts
  869. just like normal `=': it defines a recursively-expanded variable.
  870. However, when there *is* a previous definition, exactly what `+=' does
  871. depends on what flavor of variable you defined originally.  *Note The
  872. Two Flavors of Variables: Flavors, for an explanation of the two
  873. flavors of variables.
  874.    When you add to a variable's value with `+=', `make' acts
  875. essentially as if you had included the extra text in the initial
  876. definition of the variable.  If you defined it first with `:=', making
  877. it a simply-expanded variable, `+=' adds to that simply-expanded
  878. definition, and expands the new text before appending it to the old
  879. value just as `:=' does (*note Setting Variables: Setting., for a full
  880. explanation of `:=').  In fact,
  881.      variable := value
  882.      variable += more
  883. is exactly equivalent to:
  884.      variable := value
  885.      variable := $(variable) more
  886.    On the other hand, when you use `+=' with a variable that you defined
  887. first to be recursively-expanded using plain `=', `make' does something
  888. a bit different.  Recall that when you define a recursively-expanded
  889. variable, `make' does not expand the value you set for variable and
  890. function references immediately.  Instead it stores the text verbatim,
  891. and saves these variable and function references to be expanded later,
  892. when you refer to the new variable (*note The Two Flavors of Variables:
  893. Flavors.).  When you use `+=' on a recursively-expanded variable, it is
  894. this unexpanded text to which `make' appends the new text you specify.
  895.      variable = value
  896.      variable += more
  897. is roughly equivalent to:
  898.      temp = value
  899.      variable = $(temp) more
  900. except that of course it never defines a variable called `temp'.  The
  901. importance of this comes when the variable's old value contains
  902. variable references.  Take this common example:
  903.      CFLAGS = $(includes) -O
  904.      ...
  905.      CFLAGS += -pg # enable profiling
  906. The first line defines the `CFLAGS' variable with a reference to another
  907. variable, `includes'.  (`CFLAGS' is used by the rules for C
  908. compilation; *note Catalogue of Implicit Rules: Catalogue of Rules..)
  909. Using `=' for the definition makes `CFLAGS' a recursively-expanded
  910. variable, meaning `$(includes) -O' is *not* expanded when `make'
  911. processes the definition of `CFLAGS'.  Thus, `includes' need not be
  912. defined yet for its value to take effect.  It only has to be defined
  913. before any reference to `CFLAGS'.  If we tried to append to the value
  914. of `CFLAGS' without using `+=', we might do it like this:
  915.      CFLAGS := $(CFLAGS) -pg # enable profiling
  916. This is pretty close, but not quite what we want.  Using `:=' redefines
  917. `CFLAGS' as a simply-expanded variable; this means `make' expands the
  918. text `$(CFLAGS) -pg' before setting the variable.  If `includes' is not
  919. yet defined, we get ` -O -pg', and a later definition of `includes'
  920. will have no effect.  Conversely, by using `+=' we set `CFLAGS' to the
  921. *unexpanded* value `$(includes) -O -pg'.  Thus we preserve the
  922. reference to `includes', so if that variable gets defined at any later
  923. point, a reference like `$(CFLAGS)' still uses its value.
  924.