* Removed Bourne shell $(a-b), etc. variable references.

* Fixed foreach documentation slightly.
* Added chapter listing features tersely.

1 files changed, 190 insertions, 47 deletions

diff --git a/make.texinfo b/make.texinfo
index 08cd9b1..aa24937 100644
--- a/make.texinfo
+++ b/make.texinfo
@@ -114,7 +114,11 @@ be recompiled, or how.  @xref{Running}.
 * Implicit::	Implicit rules take over if the makefile doesn't say
 		 how a file is to be remade.
 * Archives::	How to use @code{make} to update archive files.
-* Missing::	Features of other @code{make}s not supported by GNU @code{make}.
+
+* Features::	GNU @code{make}'s advanced features and how GNU @code{make}
+		 relates to other versions of @code{make}.
+* Missing::	Features of other @code{make}s not supported
+		 by GNU @code{make}.
 
 * Concept Index::Index of cross-references to where concepts are discussed.
 * Name Index::	Index of cross-references for names of @code{make}'s
@@ -1900,12 +1904,10 @@ variables (@pxref{Automatic}).
 @subsection Modified References
 @cindex modified variable reference
 @cindex substitution variable reference
-@cindex conditional variable reference
 
-In addition to simple references, variables can be referenced in manners
-which modify the value of the reference but do not modify the value of
-the variable referenced.  There are two categories of modified references:
-@dfn{substitution references} and @dfn{conditional references}.@refill
+In addition to simple references, variables can be referenced in a manner
+which modifies the value of the reference but do not modify the value of
+the variable referenced.  Such a reference is a @dfn{substitution reference}.
 
 A @dfn{substitution reference} is really a simplified form of the
 @code{patsubst} expansion function (@pxref{Functions}).  It has the form
@@ -1922,34 +1924,6 @@ bar := $(foo:.o=.c)
 @noindent
 sets @samp{bar} to @samp{a.c b.c c.c}.  @xref{Setting}.
 
-@dfn{Conditional references} are references whose value depends on
-whether or not some variable is set.  They are inspired by the similar
-construct in the shell @code{sh}.  The syntax of conditional references is:
-
-@table @code
-@item $(@var{a}:-@var{b})
-This expands to the value of the variable @var{a} if it is defined or
-to @var{b} (a literal string) if it is not.
-
-@item $(@var{a}:+@var{b})
-This expands to @var{b} if the variable @var{a} is defined or to
-nothing (no characters) if it is not.
-
-@item $(@var{a}:@var{b}-@var{c})
-This expands to @var{b} if the variable @var{a} is defined or to
-@var{c} (a literal string) if it is not.
-@end table
-
-For the purpose of these conditional references, a variable is ``defined''
-if it exists and is non-null.
-
-In the first two alternatives, the @samp{:} may be omitted to produce
-a slightly different effect: then the variable @var{a} is considered
-``defined'' if it has been assigned any value, even a null value.
-
-Note that a variable value consisting solely of whitespace is @emph{not}
-null.
-
 @node Values, Flavors, Reference, Variables
 @section How Variables Get Their Values
 
@@ -1972,8 +1946,7 @@ Several @dfn{automatic} variables are given new values for each rule.
 @xref{Automatic}.
 
 @item
-Several variables have constant initial values.  @xref{Implicit
-Variables}.
+Several variables have constant initial values.  @xref{Implicit Variables}.
 @end itemize
 
 @node Flavors, Setting, Values, Variables
@@ -2008,12 +1981,12 @@ all:;echo $(foo)
 @end example
 
 @noindent
-will echo @samp{Huh?}: @code{$(foo)} expands to @code{$(bar)} which
-expands to @code{$(ugh)} which finally expands to @samp{Huh?}.@refill
+will echo @samp{Huh?}: @samp{$(foo)} expands to @samp{$(bar)} which
+expands to @samp{$(ugh)} which finally expands to @samp{Huh?}.@refill
 
 This flavor of variable is the only sort supported by other versions of
 @code{make}.  It has its advantages and its disadvantages.  An advantage
-(most would say) is that
+(most would say) is that:
 
 @example
 CFLAGS = $(include_dirs) -O
@@ -2030,8 +2003,8 @@ CFLAGS = $(CFLAGS) -O
 @end example
 
 @noindent
-because it will cause an infinite loop in the variable expansion.  (Actually
-@code{make} detects the infinite loop and reports an error.)
+because it will cause an infinite loop in the variable expansion.
+(Actually @code{make} detects the infinite loop and reports an error.)
 
 Another disadvantage is that any functions (@pxref{Functions}) referenced
 in the definition will be executed every time the variable is expanded.
@@ -2698,8 +2671,9 @@ files := $(wildcard a/* b/* c/* d/*)
 The value of the variable @var{var} after the @code{foreach} function call
 is the same as the value beforehand.  Other values taken from @var{list}
 are in effect only temporarily, during the execution of @code{foreach}.
-The variable @var{var} is the same flavor (recursively expanded or not)
-during @code{foreach} as it was before.  @xref{Flavors}.
+The variable @var{var} is a simply-expanded variable during the execution
+of @code{foreach} but is returned to the same flavor it was before the
+@code{foreach} when it is done.  @xref{Flavors}.
 
 If @var{var} was previously undefined, then it is defined as a recursively
 expanded variable (@samp{=}, not @samp{:=}) during the @code{foreach} and
@@ -3170,7 +3144,11 @@ On these occasions, you should use the @samp{-k} flag.  This tells
 targets, remaking them if necessary, before it gives up and returns nonzero
 status.  For example, after an error in compiling one object file,
 @samp{make -k} will continue compiling other object files even though it
-already knows that linking them will be impossible.  @xref{Options}.
+already knows that linking them will be impossible.  In addition to
+contuing after failing shell commands, @samp{make -k} will continue as much
+as possible after discovering that it doesn't know how to make a target or
+dependency file.  This will always cause an error message, but without
+@samp{-k}, it is a fatal error.  @xref{Options}.
 
 The usual behavior of @code{make} assumes that your purpose is to get the
 goals up to date; once @code{make} learns that this is impossible, it might
@@ -3189,7 +3167,8 @@ Here is a table of all the options @code{make} understands:
 
 @table @samp
 @item -b
-This option is ignored for compatibility with other versions of @code{make}.
+@itemx -m
+These options are ignored for compatibility with other versions of @code{make}.
 
 @item -c @var{dir}
 Change to directory @var{dir} before executing the rules.  If multiple
@@ -4187,7 +4166,7 @@ The name of the first dependency that came via the implicit rule.
 For @code{.DEFAULT} commands, as for non-implicit commands, @samp{$*}
 and @samp{$<} are empty.  @samp{$@@} is @var{t}, as always.
 
-@node Archives, Missing, Implicit, Top
+@node Archives, Features, Implicit, Top
 @chapter Using @code{make} to Update Archive Files
 @cindex archive
 
@@ -4293,7 +4272,171 @@ running @code{ranlib}.  The rules for updating the members are not shown
 here; most likely you can omit them and use the implicit rule which copies
 files into the archive, as described in the preceding section.
 
-@node Missing, Concept Index, Archives, Top
+@node Features, Missing, Archive, Top
+@chapter Features of GNU @code{make}
+
+GNU @code{make} contains many features not in any other @code{make}
+program.  Some of them are taken from other versions of @code{make}, while
+most are new inventions of the implementors of GNU @code{make}.
+
+The standard for comparison among versions of @code{make} in this chapter
+will be the version found in standard 4.2 BSD Unix systems.  Many additions
+come from the versions of @code{make} found in other Unix systems.  This
+chapter lists the features of GNU @code{make} beyond the 4.2 BSD version.
+They are presented as a simple list of small items with terse descriptions.
+All of these features (as well as those found in 4.2 BSD @code{make}) are
+documented in this manual, so it would be redundant to repeat that
+documentation here.
+
+The @code{VPATH} variable and its special meaning come from the @code{make}
+in 4.3 BSD Unix.  @xref{Directory Search}.
+
+Many features come from the version of @code{make} in Sun Unix systems.  I
+believe that these in turn are adopted from the @code{make} in Unix System V.
+
+@itemize @bullet
+@item
+Included makefiles.  @xref{Include}.
+
+@item
+Variables are read in from the environment.
+All variables are placed into the environment of child processes (running
+commands).  @xref{Environment}.  Note also the @samp{-e} option.
+
+@item
+The environment variable @samp{MAKEFLAGS} is scanned for command-line
+options to @code{make}.  The options @samp{-f}, @samp{-p}, @samp{-d} and
+@samp{-c} are not accepted.  The @code{make} variable @samp{MAKEFLAGS} is
+set to a list of the options @code{make} was invoked with, except those
+noted above.  @xref{Options/Recursion}.@refill
+
+@item
+The automatic variable @code{$%} is set to the member name
+in an archive reference.  @xref{Automatic}.
+
+@item
+The automatic variables @code{$@@}, @code{$*}, @code{$<} and @code{$%} have
+corresponding forms such as @code{$(@@F)} and @code{$(@@D)} which with only
+the filename and only the directory.  @xref{Automatic}.@refill
+
+@item
+Substitution variable references.  @xref{Reference}.
+
+@item
+The command-line options @samp{-b} and @samp{-m} are accepted and ignored.
+
+@item
+Targets whose commands contain a reference to the variable @code{MAKE} have
+their commands executed even if the @samp{-n}, @samp{-q} or @samp{-t}
+options are specified.  @xref{Recursion}.  I'm told that Unix System V
+@code{make} does this only in the case of @samp{-n}.@refill
+
+@item
+An implicit suffix rule @samp{@var{x}.a:} makes
+@file{@var{lib}(@var{name}.o)} from @file{@var{name}.@var{x}}.  In GNU
+@code{make}, this is actually implemented by using one pattern rule for
+making library-archive files and rule-chaining.  @xref{Chaining}.@refill
+@end itemize
+
+The Sun Unix (and probably System V) version of @code{make} fails to
+support variable references using braces (@samp{@{} and @samp{@}}) rather
+than parantheses (@pxref{Reference}), and to set the @code{MFLAGS} variable
+to the list of options (the same list as in @code{MAKEFLAGS}).@refill
+
+The remaining new features are inventions new to GNU @code{make}.
+
+@itemize @bullet
+@item
+The arrangement of lines and backslash-newline combinations in
+commands is retained when the commands are printed, so they
+appear as they do in the makefile, except for the stripping of
+initial whitespace.
+This has been implemented in several versions of @code{make}.
+We're not sure who invented it first, but it's been spread around a bit.
+The @samp{-v} option prints version and copyright information.
+Rule chaining and implicit intermediate files.
+we got this from either of them or thought it up ourselves at the
+The automatic variable @code{$^} containing a list of all dependencies
+of the current target.  @xref{Automatic}.
+@end itemize
+The variable @code{MAKEOVERRIDES} is defined to contain all
+the variable definitions given on the command line, and is
+appended to the @code{MAKE} variable which contains the name
+by which @code{make} was invoked.  Thus, sub-makes will always
+get variable definitions from the command line that cannot
+come from the environment since environment variable
+definitions do not override those in makefiles.
+@itemize @bullet
+@item
+The @samp{-c} to change directory.  @xref{Options}.
+
+@item
+Simply-expanded variables.  @xref{Flavors}.
+
+@item
+Phony targets.  @xref{Phony Targets}.
+@xref{Recursion}.
+
+Variable expansion functions.  @xref{Functions}.
+The @samp{-c} command option to change directory.  @xref{Options}.
+
+The @samp{-o} option makes files seem artificially old.
+@xref{Avoiding Recompilation}.
+
+@item
+Conditional lines.  @xref{Conditionals}.
+A similar feature with a different syntax was implemented by
+Andrew Hume of AT&T Bell Labs in his @code{mk} program.  This
+Included makefiles never determine the default target.
+
+@item
+There is an include file search path.  @xref{Include}.
+
+@item
+@xref{MAKEFILES Variable}.
+@xref{Avoid Compilation}.
+
+@xref{Pattern Rules}.
+@code{make}; it seems a natural extension derived from the features
+of the C preprocessor and similar macro languages and is not a
+The automatic variable @code{$^} contains a list of all
+dependencies of the current target.  @xref{Automatic}.
+@item
+Included makefiles never determine the default goal.
+There is a fully complete default set of implicit rules using
+file with suffixes @samp{.out}, @samp{.a}, @samp{.o},
+@samp{.s}, @samp{.c}, @samp{.f}, @samp{.p}, @samp{.F},
+@samp{.e}, @samp{.r}, @samp{.y}, @samp{.ye}, @samp{.yr} and
+@samp{.l}.  @xref{Catalogue of Rules}.@refill
+
+@item
+Leading sequences of @samp{./} are stripped from file names,
+so that @file{./@var{file}} and @file{@var{file}} are
+considered to be the same file.
+@item
+Stripping leading sequences of @samp{./} from file names, so that
+Dependencies of the form @samp{-l@var{name}} are searched for
+as library archives.  @xref{Library Search}.
+same file.
+
+Suffixes for suffix rules (@pxref{Suffix Rules}) may contain
+any characters.  In other version of @code{make}, they must
+begin with @samp{.} and not contain any @samp{/} characters.
+
+@item
+The variable @code{MAKELEVEL} keeps track of the current level
+of @code{make} recursion.  At the top level (@code{MAKELEVEL}
+is zero), the @code{SHELL} environment variable is not used to
+execute commands.  It is reset to @samp{/bin/sh}.@refill
+
+@item
+Intermediate implicit files.  @xref{Chained Rules}.
+Special search method for library dependencies written in the form
+@samp{-l@var{name}}.  @xref{Libraries/Search}.
+
+@samp{.} and not contain any @samp{/} characters.
+
+@item
 The variable @code{MAKELEVEL} which keeps track of the current level
 of @code{make} recursion.  @xref{Recursion}.
 The @code{make} programs in various other systems support three features