make.texi

Timestamp:

Sep 15, 2006 5:09:38 AM (18 years ago)

Author:

bird

Message:

Untested merge with GNU Make v3.81 (vendor/gnumake/2005-05-16 -> vendor/gnumake/current).

File:

: 1 edited

trunk/src/gmake/doc/make.texi (modified) (72 diffs)

Legend:

: Unmodified
: Added
: Removed

trunk/src/gmake/doc/make.texi

-              r281
+              r503
 @c %**start of header
 @setfilename make.info
+@include version.texi
+@set EDITION 0.70
+@set RCSID $Id: make.texi,v 1.45 2006/04/01 06:36:40 psmith Exp $
 @settitle GNU @code{make}
 @setchapternewpage odd
-@c %**end of header
-@c FSF publishers: format makebook.texi instead of using this file directly.
-@set RCSID $Id: make.texi,v 1.30 2005/05/13 12:45:31 psmith Exp $
-@set EDITION 0.70
-@set VERSION 3.81
-@set UPDATED 07 May 2005
-@set UPDATE-MONTH May 2005
-@c ISBN provided by Lisa M. Opus Goldstein <[email protected]>, 5 May 2004
-@set ISBN 1-882114-83-5
-@c finalout
-@c ISPELL CHECK: done, 10 June 1993 --roland
-@c ISPELL CHECK: done, 2000-06-25 --Martin Buchholz
 @c Combine the variable and function indices:
 @syncodeindex vr fn
 @c Combine the program and concept indices:
 @syncodeindex pg cp
+@c FSF publishers: format makebook.texi instead of using this file directly.
+@c ISBN provided by Lisa M. Opus Goldstein <[email protected]>, 5 May 2004
+@set ISBN 1-882114-83-5
+@c %**end of header
+@copying
+This file documents the GNU @code{make} utility, which determines
+automatically which pieces of a large program need to be recompiled,
+and issues the commands to recompile them.
+This is Edition @value{EDITION}, last updated @value{UPDATED},
+of @cite{The GNU Make Manual}, for GNU @code{make} version @value{VERSION}.
+Copyright @copyright{} 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
+, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006
+Free Software Foundation, Inc.
+@quotation
+Permission is granted to copy, distribute and/or modify this document
+under the terms of the GNU Free Documentation License, Version 1.2 or
+any later version published by the Free Software Foundation; with no
+Invariant Sections, with the Front-Cover Texts being ``A GNU Manual,''
+and with the Back-Cover Texts as in (a) below.  A copy of the
+license is included in the section entitled ``GNU Free Documentation
+License.''
+(a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify
+this GNU Manual, like GNU software.  Copies published by the Free
+Software Foundation raise funds for GNU development.''
+@end quotation
+@end copying
+@c finalout
+@c ISPELL CHECK: done, 10 June 1993 --roland
+@c ISPELL CHECK: done, 2000-06-25 --Martin Buchholz
 @dircategory GNU Packages
 …
 * Make: (make).            Remake files automatically.
 @end direntry
-@ifnottex
-This file documents the GNU Make utility, which determines
-automatically which pieces of a large program need to be recompiled,
-and issues the commands to recompile them.
-This is Edition @value{EDITION}, last updated @value{UPDATED},
-of @cite{The GNU Make Manual}, for @code{make}, Version @value{VERSION}.
-Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
-, 1999, 2000, 2002, 2003, 2004, 2005
-Free Software Foundation, Inc.
-Permission is granted to copy, distribute and/or modify this document
-under the terms of the GNU Free Documentation License, Version 1.1 or
-any later version published by the Free Software Foundation; with no
-Invariant Sections, with no Front-Cover Texts, and with no Back-Cover
-Texts.  A copy of the license is included in the section entitled
-``GNU Free Documentation License''.
-@end ifnottex
 @iftex
 …
 @subtitle A Program for Directing Recompilation
 @subtitle GNU @code{make} Version @value{VERSION}
 @subtitle @value{UPDATE-MONTH}
+@subtitle @value{UPDATED-MONTH}
 @author Richard M. Stallman, Roland McGrath, Paul D. Smith
 @page
 @vskip 0pt plus 1filll
+Copyright @copyright{} 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
+, 1997, 1998, 1999, 2000, 2002, 2003, 2004 Free Software Foundation, Inc.
+@insertcopying
 @sp 2
 Published by the Free Software Foundation @*
 Temple Place -- Suite 330, @*
 Boston, MA 02111-1307 USA @*
+Franklin St. -- Fifth Floor @*
+Boston, MA 02110-1301 USA @*
 ISBN @value{ISBN} @*
-Permission is granted to copy, distribute and/or modify this document
-under the terms of the GNU Free Documentation License, Version 1.1 or
-any later version published by the Free Software Foundation; with the
-Invariant Sections being ``GNU General Public License'', the Front-Cover
-Texts being ``A GNU Manual'', and with the Back-Cover Texts being as in
-(a) below.  A copy of the license is included in the section entitled
-``GNU Free Documentation License''.
-(a) The FSF's Back-Cover Text is:
-@quotation
-      You have freedom to copy and modify this GNU Manual, like GNU
-      software.  Copies published by the Free Software Foundation raise
-      funds for GNU development.
-@end quotation
 @sp 2
 Cover art by Etienne Suvasa.
 @end titlepage
+@page
+@summarycontents
+@contents
 @ifnottex
 @node Top, Overview, (dir), (dir)
+@top Make
+The GNU @code{make} utility automatically determines which pieces of a
+large program need to be recompiled, and issues the commands to
+recompile them.@refill
+This edition of the @cite{GNU Make Manual},
+last updated @value{UPDATED},
+documents GNU @code{make} Version @value{VERSION}.@refill
+This manual describes @code{make} and contains the following chapters:@refill
+@top GNU @code{make}
+@insertcopying
 @end ifnottex
 …
 * Phony Targets::               Using a target that is not a real file's name.
 * Force Targets::               You can use a target without commands
                                   or prerequisites to mark other
                                   targets as phony.
+                                  or prerequisites to mark other targets
+                                  as phony.
 * Empty Targets::               When only the date matters and the
                                   files are empty.
 …
 Writing the Commands in Rules
+* Command Syntax::              Command syntax features and pitfalls.
 * Echoing::                     How to control when commands are echoed.
 * Execution::                   How commands are executed.
 …
 * Sequences::                   Defining canned sequences of commands.
 * Empty Commands::              Defining useful, do-nothing commands.
+Command Syntax
+* Splitting Lines::             Breaking long command lines for readability.
+* Variables in Commands::       Using @code{make} variables in commands.
+Command Execution
+* Choosing the Shell::          How @code{make} chooses the shell used
+                                  to run commands.
 Recursive Use of @code{make}
 …
 * Text Functions::              General-purpose text manipulation functions.
 * File Name Functions::         Functions for manipulating file names.
+* Conditional Functions::       Functions that implement conditions.
 * Foreach Function::            Repeat some text with controlled variation.
-* If Function::                 Conditionally expand a value.
 * Call Function::               Expand a user-defined function.
 * Value Function::              Return the un-expanded value of a variable.
 * Eval Function::               Evaluate the arguments as makefile syntax.
 * Origin Function::             Find where a variable got its value.
+* Flavor Function::             Find out the flavor of a variable.
 * Shell Function::              Substitute the output of a shell command.
 * Make Control Functions::      Functions that control how make runs.
 …
 * Chained Rules::               How to use a chain of implicit rules.
 * Pattern Rules::               How to define new implicit rules.
 * Last Resort::                 How to defining commands for rules
                                   which cannot find any.
+* Last Resort::                 How to define commands for rules which
+                                  cannot find any.
 * Suffix Rules::                The old-fashioned style of implicit rule.
 * Implicit Rule Search::        The precise algorithm for applying
 …
 * Archive Symbols::             How to update archive symbol directories.
-Makefile Conventions
-* Makefile Basics::             General Conventions for Makefiles
-* Utilities in Makefiles::      Utilities in Makefiles
-* Command Variables::           Variables for Specifying Commands
-* Directory Variables::         Variables for Installation Directories
-* Standard Targets::            Standard Targets for Users
-* Install Command Categories::  Three categories of commands in the `install'
 @end detailmenu
 …
 @noindent
+@var{filenames} can contain shell file name patterns.
+@var{filenames} can contain shell file name patterns.  If
+@var{filenames} is empty, nothing is included and no error is printed.
 @cindex shell file name pattern (in @code{include})
 @cindex shell wildcards (in @code{include})
 …
 @code{.DEFAULT_GOAL} variable allows you to discover the current
 default goal, restart the default goal selection algorithm by clearing
 its value, or to explicitly set the default goal. The following
+its value, or to explicitly set the default goal.  The following
 example illustrates these cases:
 …
 Note that assigning more than one target name to @code{.DEFAULT_GOAL} is
 illegal and will result in an error.
+@vindex MAKE_RESTARTS @r{(number of times @code{make} has restarted)}
+@item MAKE_RESTARTS
+This variable is set only if this instance of @code{make} has
+restarted (@pxref{Remaking Makefiles, , How Makefiles Are Remade}): it
+will contain the number of times this instance has restarted.  Note
+this is not the same as recursion (counted by the @code{MAKELEVEL}
+variable).  You should not set, modify, or export this variable.
 @vindex .VARIABLES @r{(list of variables)}
 …
 @table @samp
+@item archives
+Supports @code{ar} (archive) files using special filename syntax.
+@xref{Archives, ,Using @code{make} to Update Archive Files}.
+@item check-symlink
+Supports the @code{-L} (@code{--check-symlink-times}) flag.
+@xref{Options Summary, ,Summary of Options}.
+@item else-if
+Supports ``else if'' non-nested conditionals.  @xref{Conditional
+Syntax, ,Syntax of Conditionals}.
+@item jobserver
+Supports ``job server'' enhanced parallel builds.  @xref{Parallel,
+,Parallel Execution}.
+@item second-expansion
+Supports secondary expansion of prerequisite lists.
+@item order-only
+Supports order-only prerequisites.  @xref{Prerequisite Types, ,Types
+of Prerequisites}.
 @item target-specific
 Supports target-specific and pattern-specific variable assignments.
 @xref{Target-specific, ,Target-specific Variable Values}.
-@item order-only
-Supports order-only prerequisites.  @xref{Prerequisite Types, ,Types
-of Prerequisites}.
-@item second-expansion
-Supports secondary expansion of prerequisite lists.
-@item jobserver
-Supports ``job server'' enhanced parallel builds.  @xref{Parallel,
-,Parallel Execution}.
-@item check-symlink
-Supports the @code{-L} (@code{--check-symlink-times}) flag.
-@xref{Options Summary, ,Summary of Options}.
 @end table
+@vindex .INCLUDE_DIRS @r{(list of include directories)}
+@item .INCLUDE_DIRS
+Expands to a list of directories that @code{make} searches for
+included makefiles (@pxref{Include, , Including Other Makefiles}).
 @end table
 …
 @cindex expansion, secondary
+@findex .SECONDEXPANSION
 In the previous section we learned that GNU @code{make} works in two
 distinct phases: a read-in phase and a target-update phase
+(@pxref{Reading Makefiles, , How @code{make} Reads a Makefile}).
+There is an extra wrinkle that comes in between those two phases,
+right at the end of the read-in phase: at that time, all the
+prerequisites of all of the targets are expanded a @emph{second time}.
+In most circumstances this secondary expansion will have no effect,
+since all variable and function references will have been expanded
+during the initial parsing of the makefiles.  In order to take
+advantage of the secondary expansion phase of the parser, then, it's
+necessary to @emph{escape} the variable or function reference in the
+makefile.  In this case the first expansion merely un-escapes the
+reference but doesn't expand it, and expansion is left to the
+secondary expansion phase.  For example, consider this makefile:
+@example
+(@pxref{Reading Makefiles, , How @code{make} Reads a Makefile}).  GNU
+make also has the ability to enable a @emph{second expansion} of the
+prerequisites (only) for some or all targets defined in the makefile.
+In order for this second expansion to occur, the special target
+@code{.SECONDEXPANSION} must be defined before the first prerequisite
+list that makes use of this feature.
+If that special target is defined then in between the two phases
+mentioned above, right at the end of the read-in phase, all the
+prerequisites of the targets defined after the special target are
+expanded a @emph{second time}.  In most circumstances this secondary
+expansion will have no effect, since all variable and function
+references will have been expanded during the initial parsing of the
+makefiles.  In order to take advantage of the secondary expansion
+phase of the parser, then, it's necessary to @emph{escape} the
+variable or function reference in the makefile.  In this case the
+first expansion merely un-escapes the reference but doesn't expand it,
+and expansion is left to the secondary expansion phase.  For example,
+consider this makefile:
+@example
+.SECONDEXPANSION:
 ONEVAR = onefile
 TWOVAR = twofile
 …
 @example
+.SECONDEXPANSION:
 AVAR = top
 onefile: $(AVAR)
 …
 defer the expansion by escaping the @code{$}.  Also, secondary
 expansion occurs for both explicit and implicit (pattern) rules.
+Knowing this, the possible uses for this feature are almost endless.
+For example:
+@example
+Knowing this, the possible uses for this feature increase
+dramatically.  For example:
+@example
+.SECONDEXPANSION:
 main_OBJS := main.o try.o test.o
 lib_OBJS := lib.o api.o
 …
 lib_SRCS := lib.c api.c
+.SECONDEXPANSION:
 main lib: $$(patsubst %.c,%.o,$$($$@@_SRCS))
 @end example
 …
 of all prerequisites of rules @emph{that have already appeared} for
 the same target (@code{$$+} with repetitions and @code{$$^}
+without). The following example will help illustrate these behaviors:
+@example
+without).  The following example will help illustrate these behaviors:
+@example
+.SECONDEXPANSION:
 foo: foo.1 bar.1 $$< $$^ $$+    # line #1
 …
 @end example
+For the first line, all three variables (@code{$$<}, @code{$$^}, and
 @code{$$+}) expand to the empty string. For the second line, they will
+have values @code{foo.1}, @code{foo.1 bar.1}, and @code{foo.1 bar.1}
+respectively. For the third they will have values @code{foo.1},
 @code{foo.1 bar.1 foo.2 bar.2}, and @code{foo.1 bar.1 foo.2 bar.2}
 respectively.
+In the first prerequisite list, all three variables (@code{$$<},
+@code{$$^}, and @code{$$+}) expand to the empty string.  In the
+second, they will have values @code{foo.1}, @code{foo.1 bar.1}, and
+@code{foo.1 bar.1} respectively.  In the third they will have values
+@code{foo.1}, @code{foo.1 bar.1 foo.2 bar.2}, and @code{foo.1 bar.1
+foo.2 bar.2} respectively.
 Rules undergo secondary expansion in makefile order, except that
 …
 @example
+.SECONDEXPANSION:
 foo: bar
 …
 @example
+.SECONDEXPANSION:
 /tmp/foo.o:
 …
 * Phony Targets::               Using a target that is not a real file's name.
 * Force Targets::               You can use a target without commands
                                   or prerequisites to mark other
                                   targets as phony.
+                                  or prerequisites to mark other targets
+                                  as phony.
 * Empty Targets::               When only the date matters and the
                                   files are empty.
 …
 appear on the line after the prerequisites, with a tab character, or may
 appear on the same line, with a semicolon.  Either way, the effect is the
+same.  @xref{Commands, ,Writing the Commands in Rules}.
+same.  There are other differences in the syntax of command lines.
+@xref{Commands, ,Writing the Commands in Rules}.
 @cindex dollar sign (@code{$}), in rules
 @cindex @code{$}, in rules
+@cindex rule, and @code{$}
+Because dollar signs are used to start variable references, if you really
+want a dollar sign in a rule you must write two of them, @samp{$$}
+(@pxref{Using Variables, ,How to Use Variables}).  In prerequisite
+lists you must actually write @emph{four} dollar signs (@samp{$$$$}),
+due to secondary expansion (@pxref{Secondary Expansion}).
+You may split a long line by inserting a backslash
+followed by a newline, but this is not required, as @code{make} places no
+limit on the length of a line in a makefile.
+@cindex rules, and @code{$}
+Because dollar signs are used to start @code{make} variable
+references, if you really want a dollar sign in a target or
+prerequisite you must write two of them, @samp{$$} (@pxref{Using
+Variables, ,How to Use Variables}).  If you have enabled secondary
+expansion (@pxref{Secondary Expansion}) and you want a literal dollar
+sign in the prerequisites lise, you must actually write @emph{four}
+dollar signs (@samp{$$$$}).
+You may split a long line by inserting a backslash followed by a
+newline, but this is not required, as @code{make} places no limit on
+the length of a line in a makefile.
 A rule tells @code{make} two things: when the targets are out of date,
 …
 @var{HOME}.@refill
 Wildcard expansion happens automatically in targets, in prerequisites,
+and in commands (where the shell does the expansion).  In other
+contexts, wildcard expansion happens only if you request it explicitly
 with the @code{wildcard} function.
+Wildcard expansion is performed by @code{make} automatically in
+targets and in prerequisites.  In commands the shell is responsible
+for wildcard expansion.  In other contexts, wildcard expansion happens
+only if you request it explicitly with the @code{wildcard} function.
 The special significance of a wildcard character can be turned off by
 …
 word in the list will be used.
 The default value for @code{.LIBPATTERNS} is ``@samp{lib%.so lib%.a}'',
+The default value for @code{.LIBPATTERNS} is @samp{lib%.so lib%.a},
 which provides the default behavior described above.
 …
 it will do so even if @code{make} is invoked with the @code{-k} option,
 which is unfortunate.  Second, and perhaps more importantly, you cannot
 take advantage of the parallel build capabilities of make using this
 method, since there is only one rule.
+take advantage of @code{make}'s ability to build targets in parallel
+(@pxref{Parallel, ,Parallel Execution}), since there is only one rule.
 By declaring the subdirectories as phony targets (you must do this as
 …
 as secondary (i.e., no target is removed because it is considered
 intermediate).
+@findex .SECONDEXPANSION
+@item .SECONDEXPANSION
+If @code{.SECONDEXPANSION} is mentioned as a target anywhere in the
+makefile, then all prerequisite lists defined @emph{after} it appears
+will be expanded a second time after all makefiles have been read in.
+@xref{Secondary Expansion, ,Secondary Expansion}.
+The prerequisites of the special target @code{.SUFFIXES} are the list
+of suffixes to be used in checking for suffix rules.
+@xref{Suffix Rules, , Old-Fashioned Suffix Rules}.
 @findex .DELETE_ON_ERROR
 …
 @group
 %.d: %.c
         @set -e; rm -f $@@; \
+        @@set -e; rm -f $@@; \
          $(CC) -M $(CPPFLAGS) $< > $@@.$$$$; \
          sed 's,\($*\)\.o[ :]*,\1.o $@@ : ,g' < $@@.$$$$ > $@@; \
 …
 @cindex writing rule commands
+The commands of a rule consist of shell command lines to be executed one
+by one.  Each command line must start with a tab, except that the first
+command line may be attached to the target-and-prerequisites line with a
+semicolon in between.  Blank lines and lines of just comments may appear
+among the command lines; they are ignored.  (But beware, an apparently
+``blank'' line that begins with a tab is @emph{not} blank!  It is an
+empty command; @pxref{Empty Commands}.)
+The commands of a rule consist of one or more shell command lines to
+be executed, one at a time, in the order they appear.  Typically, the
+result of executing these commands is that the target of the rule is
+brought up to date.
 Users use many different shell programs, but commands in makefiles are
 …
 otherwise.  @xref{Execution, ,Command Execution}.
-@cindex comments, in commands
-@cindex commands, comments in
-@cindex @code{#} (comments), in commands
-The shell that is in use determines whether comments can be written on
-command lines, and what syntax they use.  When the shell is
-@file{/bin/sh}, a @samp{#} starts a comment that extends to the end of
-the line.  The @samp{#} does not have to be at the beginning of a line.
-Text on a line before a @samp{#} is not part of the comment.
 @menu
+* Command Syntax::              Command syntax features and pitfalls.
 * Echoing::                     How to control when commands are echoed.
 * Execution::                   How commands are executed.
 …
 @end menu
+@node Echoing, Execution, Commands, Commands
+@node Command Syntax, Echoing, Commands, Commands
+@section Command Syntax
+@cindex command syntax
+@cindex syntax of commands
+Makefiles have the unusual property that there are really two distinct
+syntaxes in one file.  Most of the makefile uses @code{make} syntax
+(@pxref{Makefiles, ,Writing Makefiles}).  However, commands are meant to be
+interpreted by the shell and so they are written using shell syntax.
+The @code{make} program does not try to understand shell syntax: it
+performs only a very few specific translations on the content of the
+command before handing it to the shell.
+Each command line must start with a tab, except that the first command
+line may be attached to the target-and-prerequisites line with a
+semicolon in between.  @emph{Any} line in the makefile that begins
+with a tab and appears in a ``rule context'' (that is, after a rule
+has been started until another rule or variable definition) will be
+considered a command line for that rule.  Blank lines and lines of
+just comments may appear among the command lines; they are ignored.
+Some consequences of these rules include:
+@itemize @bullet
+@item
+A blank line that begins with a tab is not blank: it's an empty
+command (@pxref{Empty Commands}).
+@cindex comments, in commands
+@cindex commands, comments in
+@cindex @code{#} (comments), in commands
+@item
+A comment in a command line is not a @code{make} comment; it will be
+passed to the shell as-is.  Whether the shell treats it as a comment
+or not depends on your shell.
+@item
+A variable definition in a ``rule context'' which is indented by a tab
+as the first character on the line, will be considered a command line,
+not a @code{make} variable definition, and passed to the shell.
+@item
+A conditional expression (@code{ifdef}, @code{ifeq},
+etc. @pxref{Conditional Syntax, ,Syntax of Conditionals}) in a ``rule
+context'' which is indented by a tab as the first character on the
+line, will be considered a command line and be passed to the shell.
+@end itemize
+@menu
+* Splitting Lines::             Breaking long command lines for readability.
+* Variables in Commands::       Using @code{make} variables in commands.
+@end menu
+@node Splitting Lines, Variables in Commands, Command Syntax, Command Syntax
+@subsection Splitting Command Lines
+@cindex commands, splitting
+@cindex splitting commands
+@cindex commands, backslash (@code{\}) in
+@cindex commands, quoting newlines in
+@cindex backslash (@code{\}), in commands
+@cindex @code{\} (backslash), in commands
+@cindex quoting newline, in commands
+@cindex newline, quoting, in commands
+One of the few ways in which @code{make} does interpret command lines
+is checking for a backslash just before the newline.  As in normal
+makefile syntax, a single command can be split into multiple lines in
+the makefile by placing a backslash before each newline.  A sequence
+of lines like this is considered a single command, and one instance of
+the shell will be invoked to run it.
+However, in contrast to how they are treated in other places in a
+makefile, backslash-newline pairs are @emph{not} removed from the
+command.  Both the backslash and the newline characters are preserved
+and passed to the shell.  How the backslash-newline is interpreted
+depends on your shell.  If the first character of the next line
+after the backslash-newline is a tab, then that tab (and only that
+tab) is removed.  Whitespace is never added to the command.
+For example, this makefile:
+@example
+@group
+all :
+        @@echo no\
+space
+        @@echo no\
+        space
+        @@echo one \
+        space
+        @@echo one\
+         space
+@end group
+@end example
+@noindent
+consists of four separate shell commands where the output is:
+@example
+@group
+nospace
+nospace
+one space
+one space
+@end group
+@end example
+As a more complex example, this makefile:
+@example
+@group
+all : ; @@echo 'hello \
+        world' ; echo "hello \
+    world"
+@end group
+@end example
+@noindent
+will run one shell with a command script of:
+@example
+@group
+echo 'hello \
+world' ; echo "hello \
+    world"
+@end group
+@end example
+@noindent
+which, according to shell quoting rules, will yield the following output:
+@example
+@group
+hello \
+world
+hello     world
+@end group
+@end example
+@noindent
+Notice how the backslash/newline pair was removed inside the string quoted
+with double quotes (@code{"..."}), but not from the string quoted with single
+quotes (@code{'...'}).  This is the way the default shell (@file{/bin/sh})
+handles backslash/newline pairs.  If you specify a different shell in your
+makefiles it may treat them differently.
+Sometimes you want to split a long line inside of single quotes, but
+you don't want the backslash-newline to appear in the quoted content.
+This is often the case when passing scripts to languages such as Perl,
+where extraneous backslashes inside the script can change its meaning
+or even be a syntax error.  One simple way of handling this is to
+place the quoted string, or even the entire command, into a
+@code{make} variable then use the variable in the command.  In this
+situation the newline quoting rules for makefiles will be used, and
+the backslash-newline will be removed.  If we rewrite our example
+above using this method:
+@example
+@group
+HELLO = 'hello \
+world'
+all : ; @@echo $(HELLO)
+@end group
+@end example
+@noindent
+we will get output like this:
+@example
+@group
+hello world
+@end group
+@end example
+If you like, you can also use target-specific variables
+(@pxref{Target-specific, ,Target-specific Variable Values}) to obtain
+a tighter correspondence between the variable and the command that
+uses it.
+@node Variables in Commands,  , Splitting Lines, Command Syntax
+@subsection Using Variables in Commands
+@cindex variable references in commands
+@cindex commands, using variables in
+The other way in which @code{make} processes commands is by expanding
+any variable references in them (@pxref{Reference,Basics of Variable
+References}).  This occurs after make has finished reading all the
+makefiles and the target is determined to be out of date; so, the
+commands for targets which are not rebuilt are never expanded.
+Variable and function references in commands have identical syntax and
+semantics to references elsewhere in the makefile.  They also have the
+same quoting rules: if you want a dollar sign to appear in your
+command, you must double it (@samp{$$}).  For shells like the default
+shell, that use dollar signs to introduce variables, it's important to
+keep clear in your mind whether the variable you want to reference is
+a @code{make} variable (use a single dollar sign) or a shell variable
+(use two dollar signs).  For example:
+@example
+@group
+LIST = one two three
+all:
+        for i in $(LIST); do \
+            echo $$i; \
+        done
+@end group
+@end example
+@noindent
+results in the following command being passed to the shell:
+@example
+@group
+for i in one two three; do \
+    echo $i; \
+done
+@end group
+@end example
+@noindent
+which generates the expected result:
+@example
+@group
+one
+two
+three
+@end group
+@end example
+@node Echoing, Execution, Command Syntax, Commands
 @section Command Echoing
 @cindex echoing of commands
 …
 @cindex execution, of commands
 @cindex shell command, execution
+@vindex SHELL @r{(command execution)}
+When it is time to execute commands to update a target, they are executed
+by making a new subshell for each line.  (In practice, @code{make} may
+take shortcuts that do not affect the results.)
+@vindex @code{SHELL} @r{(command execution)}
+When it is time to execute commands to update a target, they are
+executed by invoking a new subshell for each command line.  (In
+practice, @code{make} may take shortcuts that do not affect the
+results.)
 @cindex @code{cd} (shell command)
+@strong{Please note:} this implies that shell commands such as @code{cd}
+that set variables local to each process will not affect the following
+command lines. @footnote{On MS-DOS, the value of current working
+directory is @strong{global}, so changing it @emph{will} affect the
+following command lines on those systems.}  If you want to use @code{cd}
+to affect the next command, put the two on a single line with a
+semicolon between them.  Then @code{make} will consider them a single
+command and pass them, together, to a shell which will execute them in
+sequence.  For example:
+@cindex shell variables, setting in commands
+@cindex commands setting shell variables
+@strong{Please note:} this implies that setting shell variables and
+invoking shell commands such as @code{cd} that set a context local to
+each process will not affect the following command lines.@footnote{On
+MS-DOS, the value of current working directory is @strong{global}, so
+changing it @emph{will} affect the following command lines on those
+systems.}  If you want to use @code{cd} to affect the next statement,
+put both statements in a single command line.  Then @code{make} will
+invoke one shell to run the entire line, and the shell will execute
+the statements in sequence.  For example:
 @example
 foo : bar/lose
+        cd bar; gobble lose > ../foo
+@end example
+@cindex commands, backslash (@code{\}) in
+@cindex commands, quoting newlines in
+@cindex backslash (@code{\}), in commands
+@cindex @code{\} (backslash), in commands
+@cindex quoting newline, in commands
+@cindex newline, quoting, in commands
+If you would like to split a single shell command into multiple lines of
+text, you must use a backslash at the end of all but the last subline.
+Such a sequence of lines is combined into a single line, by deleting the
+backslash-newline sequences, before passing it to the shell.  Thus, the
+following is equivalent to the preceding example:
+@example
+@group
+foo : bar/lose
+        cd bar;  \
+        gobble lose > ../foo
+@end group
+@end example
+        cd $(@@D) && gobble $(@@F) > ../$@@
+@end example
+@noindent
+Here we use the shell AND operator (@code{&&}) so that if the
+@code{cd} command fails, the script will fail without trying to invoke
+the @code{gobble} command in the wrong directory, which could cause
+problems (in this case it would certainly cause @file{../foo} to be
+truncated, at least).
+@menu
+* Choosing the Shell::          How @code{make} chooses the shell used
+                                  to run commands.
+@end menu
+@node Choosing the Shell,  , Execution, Execution
+@subsection Choosing the Shell
+@cindex shell, choosing the
+@cindex @code{SHELL}, value of
 @vindex SHELL
 The program used as the shell is taken from the variable @code{SHELL}.
+By default, the program @file{/bin/sh} is used.
+If this variable is not set in your makefile, the program
+@file{/bin/sh} is used as the shell.
+@cindex environment, @code{SHELL} in
+Unlike most variables, the variable @code{SHELL} is never set from the
+environment.  This is because the @code{SHELL} environment variable is
+used to specify your personal choice of shell program for interactive
+use.  It would be very bad for personal choices like this to affect the
+functioning of makefiles.  @xref{Environment, ,Variables from the
+Environment}.
+Furthermore, when you do set @code{SHELL} in your makefile that value
+is @emph{not} exported in the environment to commands that @code{make}
+invokes.  Instead, the value inherited from the user's environment, if
+any, is exported.  You can override this behavior by explicitly
+exporting @code{SHELL} (@pxref{Variables/Recursion, ,Communicating
+Variables to a Sub-@code{make}}), forcing it to be passed in the
+environment to commands.
+@vindex @code{MAKESHELL} @r{(MS-DOS alternative to @code{SHELL})}
+However, on MS-DOS and MS-Windows the value of @code{SHELL} in the
+environment @strong{is} used, since on those systems most users do not
+set this variable, and therefore it is most likely set specifically to
+be used by @code{make}.  On MS-DOS, if the setting of @code{SHELL} is
+not suitable for @code{make}, you can set the variable
+@code{MAKESHELL} to the shell that @code{make} should use; if set it
+will be used as the shell instead of the value of @code{SHELL}.
+@subsubheading Choosing a Shell in DOS and Windows
+@cindex shell, in DOS and Windows
+@cindex DOS, choosing a shell in
+@cindex Windows, choosing a shell in
+Choosing a shell in MS-DOS and MS-Windows is much more complex than on
+other systems.
 @vindex COMSPEC
 …
 The effect of the above DOS-specific processing is that a Makefile that
 says @samp{SHELL = /bin/sh} (as many Unix makefiles do), will work
 on MS-DOS unaltered if you have e.g. @file{sh.exe} installed in some
+contains @samp{SHELL = /bin/sh} (as many Unix makefiles do), will work
+on MS-DOS unaltered if you have e.g.@: @file{sh.exe} installed in some
 directory along your @code{PATH}.
-@cindex environment, @code{SHELL} in
-@vindex MAKESHELL @r{(MS-DOS alternative to @code{SHELL})}
-Unlike most variables, the variable @code{SHELL} is never set from the
-environment.  This is because the @code{SHELL} environment variable is
-used to specify your personal choice of shell program for interactive
-use.  It would be very bad for personal choices like this to affect the
-functioning of makefiles.  @xref{Environment, ,Variables from the
-Environment}.  However, on MS-DOS and MS-Windows the value of
-@code{SHELL} in the environment @strong{is} used, since on those systems
-most users do not set this variable, and therefore it is most likely set
-specifically to be used by @code{make}.  On MS-DOS, if the setting of
-@code{SHELL} is not suitable for @code{make}, you can set the variable
-@code{MAKESHELL} to the shell that @code{make} should use; this will
-override the value of @code{SHELL}.
 @node Parallel, Errors, Execution, Commands
 …
 environment is passed to the sub-@code{make}.  You can force
 @code{make} to export its value for @code{SHELL} by using the
 @code{export} directive, described below.
+@code{export} directive, described below.  @xref{Choosing the Shell}.
 The special variable @code{MAKEFLAGS} is always exported (unless you
 …
 @group
 ifeq (0,$@{MAKELEVEL@})
-cur-dir   := $(shell pwd)
 whoami    := $(shell whoami)
 host-type := $(shell arch)
 …
 @group
 $@{subdirs@}:
       $@{MAKE@} cur-dir=$@{cur-dir@}/$@@ -C $@@ all
+        $@{MAKE@} -C $@@ all
 @end group
 @end example
 …
 simply-expanded definition, and expands the new text before appending it
 to the old value just as @samp{:=} does
 (@pxref{Setting, ,Setting Variables}, for a full explanation of @samp{:=}).
+(see @ref{Setting, ,Setting Variables}, for a full explanation of @samp{:=}).
 In fact,
 …
 When @code{make} runs a command script, variables defined in the
 makefile are placed into the environment of that command.  This allows
 you to pass values to sub-@code{make} invocations. (@pxref{Recursion,
+you to pass values to sub-@code{make} invocations (@pxref{Recursion,
 ,Recursive Use of @code{make}}).  By default, only variables that came
 from the environment or the command line are passed to recursive
 …
 @cindex SHELL, import from environment
+Such problems would be especially likely with the variable @code{SHELL},
+which is normally present in the environment to specify the user's choice
+of interactive shell.  It would be very undesirable for this choice to
+affect @code{make}.  So @code{make} ignores the environment value of
+@code{SHELL} (except on MS-DOS and MS-Windows, where @code{SHELL} is
+usually not set.  @xref{Execution, ,Special handling of SHELL on
+MS-DOS}.)@refill
+@cindex SHELL, export to environment
+The @code{SHELL} variable is special in another way: just as the value
+of the @code{make} variable @code{SHELL} is not taken from the
+environment, so also it is not placed into the environment of commands
+that @code{make} invokes.  Instead, the value of @code{SHELL} from the
+invoking environment is provided to the command.  You can use
+@code{export SHELL} to force the value of the @code{make} variable
+@code{SHELL} to be placed in the environment of commands.
+Such problems would be especially likely with the variable
+@code{SHELL}, which is normally present in the environment to specify
+the user's choice of interactive shell.  It would be very undesirable
+for this choice to affect @code{make}; so, @code{make} handles the
+@code{SHELL} environment variable in a special way; see @ref{Choosing
+the Shell}.@refill
 @node Target-specific, Pattern-specific, Environment, Using Variables
 …
 will be in effect.  Note that this variable is actually distinct from
 any ``global'' value: the two variables do not have to have the same
 flavor (recursive vs. static).
+flavor (recursive vs.@: static).
 Target-specific variables have the same priority as any other makefile
 …
 you define a target-specific variable that variable value is also in
 effect for all prerequisites of this target, and all their
 prerequisites, etc. (unless those prerequisites override that variable
+prerequisites, etc.@: (unless those prerequisites override that variable
 with their own target-specific variable value).  So, for example, a
 statement like this:
 …
 * Text Functions::              General-purpose text manipulation functions.
 * File Name Functions::         Functions for manipulating file names.
+* Conditional Functions::       Functions that implement conditions.
 * Foreach Function::            Repeat some text with controlled variation.
-* If Function::                 Conditionally expand a value.
 * Call Function::               Expand a user-defined function.
 * Value Function::              Return the un-expanded value of a variable.
 * Eval Function::               Evaluate the arguments as makefile syntax.
 * Origin Function::             Find where a variable got its value.
+* Flavor Function::             Find out the flavor of a variable.
 * Shell Function::              Substitute the output of a shell command.
 * Make Control Functions::      Functions that control how make runs.
 …
 Directive, , The @code{override} Directive}).
 @node File Name Functions, Foreach Function, Text Functions, Functions
+@node File Name Functions, Conditional Functions, Text Functions, Functions
 @section Functions for File Names
 @cindex functions, for file names
 …
 For each file name in @var{names} return the canonical absolute name.
 A canonical name does not contain any @code{.} or @code{..} components,
 nor any repeated path separators (@code{/}) or symlinks. In case of a
 failure the empty string is returned. Consult the @code{realpath(3)}
+nor any repeated path separators (@code{/}) or symlinks.  In case of a
+failure the empty string is returned.  Consult the @code{realpath(3)}
 documentation for a list of possible failure causes.
 …
 For each file name in @var{names} return an absolute name that does
 not contain any @code{.} or @code{..} components, nor any repeated path
 separators (@code{/}). Note that in contrast to @code{realpath}
+separators (@code{/}).  Note that, in contrast to @code{realpath}
 function, @code{abspath} does not resolve symlinks and does not require
 the file names to refer to an existing file or directory. Use the
+the file names to refer to an existing file or directory.  Use the
 @code{wildcard} function to test for existence.
 @end table
+@node Foreach Function, If Function, File Name Functions, Functions
+@node Conditional Functions, Foreach Function, File Name Functions, Functions
+@section Functions for Conditionals
+@findex if
+@cindex conditional expansion
+There are three functions that provide conditional expansion.  A key
+aspect of these functions is that not all of the arguments are
+expanded initially.  Only those arguments which need to be expanded,
+will be expanded.
+@table @code
+@item $(if @var{condition},@var{then-part}[,@var{else-part}])
+@findex if
+The @code{if} function provides support for conditional expansion in a
+functional context (as opposed to the GNU @code{make} makefile
+conditionals such as @code{ifeq} (@pxref{Conditional Syntax, ,Syntax of
+Conditionals}).
+The first argument, @var{condition}, first has all preceding and
+trailing whitespace stripped, then is expanded.  If it expands to any
+non-empty string, then the condition is considered to be true.  If it
+expands to an empty string, the condition is considered to be false.
+If the condition is true then the second argument, @var{then-part}, is
+evaluated and this is used as the result of the evaluation of the entire
+@code{if} function.
+If the condition is false then the third argument, @var{else-part}, is
+evaluated and this is the result of the @code{if} function.  If there is
+no third argument, the @code{if} function evaluates to nothing (the
+empty string).
+Note that only one of the @var{then-part} or the @var{else-part} will be
+evaluated, never both.  Thus, either can contain side-effects (such as
+@code{shell} function calls, etc.)
+@item $(or @var{condition1}[,@var{condition2}[,@var{condition3}@dots{}]])
+@findex or
+The @code{or} function provides a ``short-circuiting'' OR operation.
+Each argument is expanded, in order.  If an argument expands to a
+non-empty string the processing stops and the result of the expansion
+is that string.  If, after all arguments are expanded, all of them are
+false (empty), then the result of the expansion is the empty string.
+@item $(and @var{condition1}[,@var{condition2}[,@var{condition3}@dots{}]])
+@findex and
+The @code{and} function provides a ``short-circuiting'' AND operation.
+Each argument is expanded, in order.  If an argument expands to an
+empty string the processing stops and the result of the expansion is
+the empty string.  If all arguments expand to a non-empty string then
+the result of the expansion is the expansion of the last argument.
+@end table
+@node Foreach Function, Call Function, Conditional Functions, Functions
 @section The @code{foreach} Function
 @findex foreach
 …
 no?), but it is more likely to be a mistake.
+@node If Function, Call Function, Foreach Function, Functions
+@section The @code{if} Function
+@findex if
+@cindex conditional expansion
+The @code{if} function provides support for conditional expansion in a
+functional context (as opposed to the GNU @code{make} makefile
+conditionals such as @code{ifeq} (@pxref{Conditional Syntax, ,Syntax of
+Conditionals}).
+An @code{if} function call can contain either two or three arguments:
+@example
+$(if @var{condition},@var{then-part}[,@var{else-part}])
+@end example
+The first argument, @var{condition}, first has all preceding and
+trailing whitespace stripped, then is expanded.  If it expands to any
+non-empty string, then the condition is considered to be true.  If it
+expands to an empty string, the condition is considered to be false.
+If the condition is true then the second argument, @var{then-part}, is
+evaluated and this is used as the result of the evaluation of the entire
+@code{if} function.
+If the condition is false then the third argument, @var{else-part}, is
+evaluated and this is the result of the @code{if} function.  If there is
+no third argument, the @code{if} function evaluates to nothing (the
+empty string).
+Note that only one of the @var{then-part} or the @var{else-part} will be
+evaluated, never both.  Thus, either can contain side-effects (such as
+@code{shell} function calls, etc.)
+@node Call Function, Value Function, If Function, Functions
+@node Call Function, Value Function, Foreach Function, Functions
 @section The @code{call} Function
 @findex call
 …
 The @code{call} function can be nested.  Each recursive invocation gets
 its own local values for @code{$(1)}, etc. that mask the values of
+its own local values for @code{$(1)}, etc.@: that mask the values of
 higher-level @code{call}.  For example, here is an implementation of a
 @dfn{map} function:
 …
 @end example
 @node Origin Function, Shell Function, Eval Function, Functions
+@node Origin Function, Flavor Function, Eval Function, Functions
 @section The @code{origin} Function
 @findex origin
 …
 @xref{Text Functions, , Functions for String Substitution and Analysis}.
+@node Shell Function, Make Control Functions, Origin Function, Functions
+@node Flavor Function, Shell Function, Origin Function, Functions
+@section The @code{flavor} Function
+@findex flavor
+@cindex variables, flavor of
+@cindex flavor of variable
+The @code{flavor} function is unlike most other functions (and like
+@code{origin} function) in that it does not operate on the values of
+variables; it tells you something @emph{about} a variable.
+Specifically, it tells you the flavor of a variable (@pxref{Flavors,
+,The Two Flavors of Variables}).
+The syntax of the @code{flavor} function is:
+@example
+$(flavor @var{variable})
+@end example
+Note that @var{variable} is the @emph{name} of a variable to inquire about;
+not a @emph{reference} to that variable.  Therefore you would not normally
+use a @samp{$} or parentheses when writing it.  (You can, however, use a
+variable reference in the name if you want the name not to be a constant.)
+The result of this function is a string that identifies the flavor of the
+variable @var{variable}:
+@table @samp
+@item undefined
+if @var{variable} was never defined.
+@item recursive
+if @var{variable} is a recursively expanded variable.
+@item simple
+if @var{variable} is a simply expanded variable.
+@end table
+@node Shell Function, Make Control Functions, Flavor Function, Functions
 @section The @code{shell} Function
 @findex shell
 …
 spawning a new shell, you should carefully consider the performance
 implications of using the @code{shell} function within recursively
 expanded variables vs. simply expanded variables (@pxref{Flavors, ,The
+expanded variables vs.@: simply expanded variables (@pxref{Flavors, ,The
 Two Flavors of Variables}).
 …
 things and many others.
+@cindex exit status of make
 The exit status of @code{make} is always one of three values:
 @table @code
 …
 Consider all targets out-of-date.  GNU @code{make} proceeds to
 consider targets and their prerequisites using the normal algorithms;
+however, all these targets are remade, regardless of the status of
+their prerequisites.
+however, all targets so considered are always remade regardless of the
+status of their prerequisites.  To avoid infinite recursion, if
+@code{MAKE_RESTARTS} (@pxref{Special Variables, , Other Special
+Variables}) is set to a number greater than 0 this option is disabled
+when considering whether to remake makefiles (@pxref{Remaking
+Makefiles, , How Makefiles Are Remade}).
 @item -C @var{dir}
 …
 * Pattern Rules::               How to define new implicit rules.
 * Last Resort::                 How to define commands for rules which
                                 cannot find any.
+                                  cannot find any.
 * Suffix Rules::                The old-fashioned style of implicit rule.
 * Implicit Rule Search::        The precise algorithm for applying
 …
 @samp{--no-builtin-rules} option cancels all predefined rules.
+This manual only documents the default rules available on POSIX-based
+operating systems.  Other operating systems, such as VMS, Windows,
+OS/2, etc. may have different sets of default rules.  To see the full
+list of default rules and variables available in your version of GNU
+@code{make}, run @samp{make -p} in a directory with no makefile.
 Not all of these rules will always be defined, even when the @samp{-r}
 option is not given.  Many of the predefined implicit rules are
 …
 the special target @code{.SUFFIXES}).  The default suffix list is:
 @code{.out}, @code{.a}, @code{.ln}, @code{.o}, @code{.c}, @code{.cc},
 @code{.C}, @code{.p}, @code{.f}, @code{.F}, @code{.r}, @code{.y},
+@code{.C}, @code{.cpp}, @code{.p}, @code{.f}, @code{.F}, @code{.r}, @code{.y},
 @code{.l}, @code{.s}, @code{.S}, @code{.mod}, @code{.sym}, @code{.def},
 @code{.h}, @code{.info}, @code{.dvi}, @code{.tex}, @code{.texinfo},
 …
 @cindex C++, rule to compile
 @pindex g++
+@pindex .cc
+@pindex .cpp
 @pindex .C
+@pindex .cc
+@file{@var{n}.o} is made automatically from @file{@var{n}.cc} or
+@file{@var{n}.C} with a command of the form @samp{$(CXX) -c $(CPPFLAGS)
+$(CXXFLAGS)}.  We encourage you to use the suffix @samp{.cc} for C++
+source files instead of @samp{.C}.@refill
+@file{@var{n}.o} is made automatically from @file{@var{n}.cc},
+@file{@var{n}.cpp}, or @file{@var{n}.C} with a command of the form
+@samp{$(CXX) -c $(CPPFLAGS) $(CXXFLAGS)}.  We encourage you to use the
+suffix @samp{.cc} for C++ source files instead of @samp{.C}.@refill
 @item Compiling Pascal programs
 …
 The commands in built-in implicit rules make liberal use of certain
 predefined variables.  You can alter these variables in the makefile,
+with arguments to @code{make}, or in the environment to alter how the
+implicit rules work without redefining the rules themselves.  You can
+cancel all variables used by implicit rules with the @samp{-R} or
 @samp{--no-builtin-variables} option.
+predefined variables.  You can alter the values of these variables in
+the makefile, with arguments to @code{make}, or in the environment to
+alter how the implicit rules work without redefining the rules
+themselves.  You can cancel all variables used by implicit rules with
+the @samp{-R} or @samp{--no-builtin-variables} option.
 For example, the command used to compile a C source file actually says
 …
 with spaces.
+Here is a table of variables used as names of programs in built-in rules:
+The following tables describe of some of the more commonly-used predefined
+variables.  This list is not exhaustive, and the default values shown here may
+not be what are selected by @code{make} for your environment.  To see the
+complete list of predefined variables for your instance of GNU @code{make} you
+can run @samp{make -p} in a directory with no makefiles.
+Here is a table of some of the more common variables used as names of
+programs in built-in rules:
+makefiles.
 @table @code
 …
 @item AS
 @vindex AS
 Program for doing assembly; default @samp{as}.
+Program for compiling assembly files; default @samp{as}.
 @pindex as
 …
 @vindex CC
 Program for compiling C programs; default @samp{cc}.
+@pindex cc
+@item CO
+@vindex CO
+Program for checking out files from RCS; default @samp{co}.
 @pindex cc
 …
 @item LEX
 @vindex LEX
+Program to use to turn Lex grammars into C programs or Ratfor programs;
+default @samp{lex}.
+Program to use to turn Lex grammars into source code; default @samp{lex}.
 @pindex lex
+@item YACC
+@vindex YACC
+Program to use to turn Yacc grammars into source code; default @samp{yacc}.
+@pindex yacc
+@item LINT
+@vindex LINT
+Program to use to run lint on source code; default @samp{lint}.
+@pindex lint
+@item M2C
+@vindex M2C
+Program to use to compile Modula-2 source code; default @samp{m2c}.
+@pindex m2c
 @item PC
 …
 Program for compiling Pascal programs; default @samp{pc}.
 @pindex pc
-@item YACC
-@vindex YACC
-Program to use to turn Yacc grammars into C programs; default @samp{yacc}.
-@pindex yacc
-@item YACCR
-@vindex YACCR
-Program to use to turn Yacc grammars into Ratfor
-programs; default @samp{yacc -r}.
 @item MAKEINFO
 …
 @item LDFLAGS
 @vindex LDFLAGS
 Extra flags to give to compilers when they are
 supposed to invoke the linker, @samp{ld}.
+Extra flags to give to compilers when they are supposed to invoke the linker,
+@samp{ld}.
 @item LFLAGS
 …
 Extra flags to give to Lex.
+@item YFLAGS
+@vindex YFLAGS
+Extra flags to give to Yacc.
 @item PFLAGS
 @vindex PFLAGS
 …
 Extra flags to give to the Fortran compiler for Ratfor programs.
 @item YFLAGS
 @vindex YFLAGS
 Extra flags to give to Yacc.
+@item LINTFLAGS
+@vindex LINTFLAGS
+Extra flags to give to lint.
 @end table
 …
 @samp{%} in a prerequisite of a pattern rule stands for the same stem
+that was matched by the @samp{%} in the target.  In order for
+the pattern rule to apply, its target pattern must match the file name
+under consideration, and its prerequisite patterns must name files that
+exist or can be made.  These files become prerequisites of the target.
+that was matched by the @samp{%} in the target.  In order for the
+pattern rule to apply, its target pattern must match the file name
+under consideration and all of its prerequisites (after pattern
+substitution) must name files that exist or can be made.  These files
+become prerequisites of the target.
 @cindex prerequisite pattern, implicit
 …
 names, along with the slash that ends them, are added on to the
 prerequisite file names generated from the pattern rule's prerequisite
 patterns and the file name. The directories are ignored only for the
+patterns and the file name.  The directories are ignored only for the
 purpose of finding an implicit rule to use, not in the application of
 that rule.  Thus, @samp{e%t} matches the file name @file{src/eat},
 …
 In fact, nearly all archive member targets are updated in just this way
 and there is an implicit rule to do it for you.  @strong{Note:} The
+and there is an implicit rule to do it for you.  @strong{Please note:} The
 @samp{c} flag to @code{ar} is required if the archive file does not
 already exist.
 …
 @xref{Origin Function, , The @code{origin} Function}.
+@item $(flavor @var{variable})
+Return a string describing the flavor of the @code{make} variable
+@var{variable}.@*
+@xref{Flavor Function, , The @code{flavor} Function}.
 @item $(foreach @var{var},@var{words},@var{text})
 …
 Evaluate the variable @var{var} replacing any references to @code{$(1)},
 @code{$(2)} with the first, second, etc. @var{param} values.@*
+@code{$(2)} with the first, second, etc.@: @var{param} values.@*
 @xref{Call Function, ,The @code{call} Function}.
 …
 commands.  @xref{Execution, ,Command Execution}.  The @code{SHELL}
 variable is handled specially when importing from and exporting to the
 environment.  @xref{Environment, ,Using Variable from the Environment}.
+environment.  @xref{Choosing the Shell}.
 @item MAKESHELL
 On MS-DOS only, the name of the command interpreter that is to be used
 by @code{make}. This value takes precedence over the value of
+by @code{make}.  This value takes precedence over the value of
 @code{SHELL}.  @xref{Execution, ,MAKESHELL variable}.
 …
 @printindex fn
-@summarycontents
-@contents
 @bye

Note: See TracChangeset for help on using the changeset viewer.

Changeset 503 in kBuild for trunk/src/gmake/doc/make.texi

Legend:

trunk/src/gmake/doc/make.texi

Download in other formats: