make.info: Features

Top

Missing

Archives

Back to Software Index

12 Features of GNU `make'
*************************

Here is a summary of the features of GNU `make', for comparison with
and credit to other versions of `make'.  We consider the features of
`make' in 4.2 BSD systems as a baseline.  If you are concerned with
writing portable makefiles, you should not use the features of `make'
listed here, nor the ones in Note: Missing.

   Many features come from the version of `make' in System V.

   * The `VPATH' variable and its special meaning.  Note: Searching
     Directories for Prerequisites.  This feature
     exists in System V `make', but is undocumented.  It is documented
     in 4.3 BSD `make' (which says it mimics System V's `VPATH'
     feature).

   * Included makefiles.  Note: Including Other Makefiles.
     Allowing multiple files to be included with a single directive is
     a GNU extension.

   * Variables are read from and communicated via the environment.
     Note: Variables from the Environment.

   * Options passed through the variable `MAKEFLAGS' to recursive
     invocations of `make'.  Note: Communicating Options to a
     Sub-`make'.

   * The automatic variable `$%' is set to the member name in an
     archive reference.  Note: Automatic Variables.

   * The automatic variables `$@', `$*', `$<', `$%', and `$?' have
     corresponding forms like `$(@F)' and `$(@D)'.  We have generalized
     this to `$^' as an obvious extension.  Note: Automatic Variables.

   * Substitution variable references.  Note: Basics of Variable
     References.

   * The command line options `-b' and `-m', accepted and ignored.  In
     System V `make', these options actually do something.

   * Execution of recursive commands to run `make' via the variable
     `MAKE' even if `-n', `-q' or `-t' is specified.  Note: Recursive
     Use of `make'.

   * Support for suffix `.a' in suffix rules.  Note: Archive Suffix
     Rules.  This feature is obsolete in GNU `make', because the
     general feature of rule chaining (*note Chains of Implicit Rules:
     Chained Rules.) allows one pattern rule for installing members in
     an archive (Note: Archive Update) to be sufficient.

   * The arrangement of lines and backslash-newline combinations in
     recipes is retained when the recipes are printed, so they appear as
     they do in the makefile, except for the stripping of initial
     whitespace.

   The following features were inspired by various other versions of
`make'.  In some cases it is unclear exactly which versions inspired
which others.

   * Pattern rules using `%'.  This has been implemented in several
     versions of `make'.  We're not sure who invented it first, but
     it's been spread around a bit.  Note: Defining and Redefining
     Pattern Rules.

   * Rule chaining and implicit intermediate files.  This was
     implemented by Stu Feldman in his version of `make' for AT&T
     Eighth Edition Research Unix, and later by Andrew Hume of AT&T
     Bell Labs in his `mk' program (where he terms it "transitive
     closure").  We do not really know if we got this from either of
     them or thought it up ourselves at the same time.  Note: Chains of
     Implicit Rules.

   * The automatic variable `$^' containing a list of all prerequisites
     of the current target.  We did not invent this, but we have no
     idea who did.  Note: Automatic Variables.  The automatic variable
     `$+' is a simple extension of `$^'.

   * The "what if" flag (`-W' in GNU `make') was (as far as we know)
     invented by Andrew Hume in `mk'.  Note: Instead of Executing
     Recipes.

   * The concept of doing several things at once (parallelism) exists in
     many incarnations of `make' and similar programs, though not in the
     System V or BSD implementations.  *Note Recipe Execution:
     Execution.

   * Modified variable references using pattern substitution come from
     SunOS 4.  Note: Basics of Variable References.  This
     functionality was provided in GNU `make' by the `patsubst'
     function before the alternate syntax was implemented for
     compatibility with SunOS 4.  It is not altogether clear who
     inspired whom, since GNU `make' had `patsubst' before SunOS 4 was
     released.

   * The special significance of `+' characters preceding recipe lines
     (Note: Instead of Executing Recipes.) is
     mandated by `IEEE Standard 1003.2-1992' (POSIX.2).

   * The `+=' syntax to append to the value of a variable comes from
     SunOS 4 `make'.  Note: Appending More Text to Variables.

   * The syntax `ARCHIVE(MEM1 MEM2...)' to list multiple members in a
     single archive file comes from SunOS 4 `make'.  Note: Archive
     Members.

   * The `-include' directive to include makefiles with no error for a
     nonexistent file comes from SunOS 4 `make'.  (But note that SunOS 4
     `make' does not allow multiple makefiles to be specified in one
     `-include' directive.)  The same feature appears with the name
     `sinclude' in SGI `make' and perhaps others.

   The remaining features are inventions new in GNU `make':

   * Use the `-v' or `--version' option to print version and copyright
     information.

   * Use the `-h' or `--help' option to summarize the options to `make'.

   * Simply-expanded variables.  *Note The Two Flavors of Variables:
     Flavors.

   * Pass command line variable assignments automatically through the
     variable `MAKE' to recursive `make' invocations.  Note: Recursive
     Use of `make'.

   * Use the `-C' or `--directory' command option to change directory.
     Note: Summary of Options.

   * Make verbatim variable definitions with `define'.  Note: Defining
     Multi-Line Variables.

   * Declare phony targets with the special target `.PHONY'.

     Andrew Hume of AT&T Bell Labs implemented a similar feature with a
     different syntax in his `mk' program.  This seems to be a case of
     parallel discovery.  Note: Phony Targets.

   * Manipulate text by calling functions.  Note: Functions for
     Transforming Text.

   * Use the `-o' or `--old-file' option to pretend a file's
     modification-time is old.  Note: Avoiding Recompilation of Some
     Files.

   * Conditional execution.

     This feature has been implemented numerous times in various
     versions of `make'; it seems a natural extension derived from the
     features of the C preprocessor and similar macro languages and is
     not a revolutionary concept.  Note: Conditional Parts of
     Makefiles.

   * Specify a search path for included makefiles.  Note: Including
     Other Makefiles.

   * Specify extra makefiles to read with an environment variable.
     Note: The Variable `MAKEFILES'.

   * Strip leading sequences of `./' from file names, so that `./FILE'
     and `FILE' are considered to be the same file.

   * Use a special search method for library prerequisites written in
     the form `-lNAME'.  *Note Directory Search for Link Libraries:
     Libraries/Search.

   * Allow suffixes for suffix rules (*note Old-Fashioned Suffix Rules:
     Suffix Rules.) to contain any characters.  In other versions of
     `make', they must begin with `.' and not contain any `/'
     characters.

   * Keep track of the current level of `make' recursion using the
     variable `MAKELEVEL'.  Note: Recursive Use of `make'.

   * Provide any goals given on the command line in the variable
     `MAKECMDGOALS'.  Note: Arguments to Specify the Goals.

   * Specify static pattern rules.  Note: Static Pattern Rules.


   * Provide selective `vpath' search.  Note: Searching Directories for
     Prerequisites.

   * Provide computed variable references.  Note: Basics of Variable
     References.

   * Update makefiles.  Note: How Makefiles Are Remade.
  System V `make' has a very, very limited form of this
     functionality in that it will check out SCCS files for makefiles.

   * Various new built-in implicit rules.  Note: Catalogue of Implicit
     Rules.

   * The built-in variable `MAKE_VERSION' gives the version number of
     `make'.