Make
In computing,
make is a
utility that automates the process of converting files from one form to another. The
make identifies and runs the programs which are necessary to convert the files (these programs are called
dependencies). Tracking dependencies is simple and centers on using the modification time of the input files. Most frequently it is used for
compiling source code into
object code, joining and then
linking object code into
executables or
libraries. It uses files called "makefiles" to determine the dependency graph for a given output, and the build scripts which need to be passed to the
shell to build them. The term makefile stems from their traditional file name of "makefile" or (later) "Makefile".
There are now a number of dependency-tracking build utilities, but
make is one of the most wide-spread, primarily due to its inclusion in
Unix, starting with the
PWB variant, which featured a variety of tools targeting software development workloads. It was originally created by
Stuart Feldman in
1977 at
Bell Labs. In
2003 Dr. Feldman
received the
ACM Software System Award for the invention of this important tool.
Before make's introduction, the Unix build system would most likely consist of "make" and "install" shell scripts accompanying a program's source. Being able to combine the commands for the different targets into a single file, and being able to abstract out dependency tracking and archive handling, was an important step in the direction of modern build environments.
Make has gone through a number of rewrites, and a number of from-scratch variants which used the same file format and basic algorithmic principles, and also provided a number of their own non-standard enhancements, in the time that followed. Some of them are:
*
BSD make, which is derived from
Adam de Boor's work on a version of make capable of building targets in
parallel, and survives with varying degrees of modification in
FreeBSD,
NetBSD and
OpenBSD. Most notably, it has conditionals and iterative loops which are applied at the parsing stage and may be used to conditionally, and programmatically, construct the makefile, including generation of targets at runtime.
*
GNU make, which is part of most
GNU/Linux installations and is frequently used in conjunction with the
GNU build system. Its notable departures from traditional make are most noticeable in pattern-matching in dependency graphs and build targets, as well as a number of functions which may be invoked to have the make utility do things like collect a list of all files in the current directory. Where BSD make has a rich set of internal macros at parse time, GNU make typically encourages the use of an external macro package like
m4.
*
makepp is a derivative of (GNU) make, but additionally offers an integrated extensible command- and include-parser. This detects implicit dependencies automatically. Changed command options and similar conditions are recognized. The big make problem with recursive builds can be elegantly avoided, to guarantee correct builds.
Perl is integratable on all levels. http://makepp.sf.net
POSIX includes standardization of the basic features and operation of the make utility, and is implemented with varying degrees of completeness in Unix-based versions of make. In general, simple makefiles may be used between various versions of make with reasonable success. Some versions of GNU make and BSD make will look first for files named "GNUmakefile" and "BSDmakefile" respectively, which allows one to put makefiles which use implementation-defined behaviour in separate locations.
Like most software which has been around for as long as make has, it has its share of fans and detractors. Many problems have surfaced with scaling make to work with modern, large software projects, some contend, but many also point out that for the common case, make works very well, and has very simple, but powerful, expressiveness. In any event, make is still used for building many complete
operating systems, and modern replacements are not very different in their basic operation.
With the advent of modern
Integrated Development Environments, especially on non-Unix platforms, many programmers do not manually manage dependency tracking, or even the listing of which files are part of a project, and instead leave that task to be automated by their environment. Likewise, many modern programming languages have language-specific ways of listing dependencies which are more efficiently tracked through the use of language-specific build utilities.
A makefile consists of lines of text which define a file (or set of files) or a rule name as depending on a set of files. Output files are marked as depending on their source files, for example, and source files are marked as depending on files which they include internally. After each dependency is listed, a series of lines of tab-
indented text may follow which define how to transform the input into the output, if the former has been modified more recently than the latter. In the case where such definitions are present, they are referred to as "build scripts" and are passed to the shell to generate the target file. The basic structure is:
# Comments use the pound sign (aka hash)target: dependencies command 1
command 2
.
.
.
command n
A makefile also can contain definitions of variables and inclusion of other makefiles. Variables in makefiles may be overridden in the
command line arguments passed to the make utility. This allows users to specify different behaviour for the build scripts and how to invoke programs, among other things. For example, the variable "CC" is frequently used in makefiles to refer to a
C compiler, and the user may wish to provide an alternate compiler to use.
Below is a very simple makefile that would compile a source called "helloworld.c" using cc, a C compiler. The PHONY tag is a technicality that tells make that a particular target name does not produce an actual file. The $@ and $< are two of the so-called automatic variables and stand for the target name and so-called "implicit" source, respectively. There are a number of other automatic variables.
Note that in the "clean" target, a
minus prefixes the command, which tells make to ignore errors in running the command; make will normally exit if execution of a command fails at any point. In the case of a target to cleanup, typically called "clean", one wants to remove any files generated by the build process, without exiting if they don't exist. By tagging the clean target PHONY, we prevent make expecting a file to be produced by that target. Note that in this particular case, the minus prefixing the command is redundant in the common case, the -f or "force" flag to rm will prevent rm exiting due to files not existing. It may exit with an error on other, unintended errors which may be worth stopping the build for.
helloworld: helloworld.o cc -o $@ $<
helloworld.o: helloworld.c cc -c -o $@ $<
.PHONY: cleanclean: -rm -f helloworld helloworld.o
There are also many tools which are like make, but which are not compatible with its makefile format. A comprehensive list is available on the
A-A-P website. Some of the most notable are:
*
Ant, which is popular for
Java development and uses an
XML file format.
*
cook, a very powerful tool with a
C like syntax.
*
dmake (distributed make), which is used in the build process for some
Sun Microsystems software, including
OpenOffice.org and
Solaris.
*
Jam, which is a generally enhanced, ground-up tool which is similar to make.
*
Apache Maven, which is very similar to ant.
*
Mk - developed originally for
Version 10 Unix and
Plan 9, said to have "improved upon make by removing all the vowels from the name", and introducing a completely new syntax that many consider to be easier to read and more powerful. It has been ported to Unix as part of
plan9port.
*
MPW Make -- Developed for
Mac OS Classic and loosely similar to but not compatible with Unix make; it was designed with somewhat more complicated dependency syntax to allow for
resource files.
Mac OS X comes with both GNU make and BSD make. Available as part of the Macintosh Programmer's Workshop as a free, unsupported download from Apple.
*
PBS - Open Source - A Make replacement written in Perl featuring hierarchical builds, dependency graph, node triggers, Perl syntax for PBSfiles, shell or Perl build actions.
*
Module, which is a Perl module for the building and installation of other Perl modules. It replaces the existing
ExtUtils module, which actually used make to do the building.
*
NAnt, a tool similar to ant for the
.NET framework*
MSBuild, the Microsoft Build Engine
*
Rake, a
Ruby-based build tool.
*
SCons, which is based around the
Python programming language, and integrates a broader set of features than make. It is based on a
Perl build driver called
Cons.
*
CMake, which is a cross platform make. It is designed to be used in conjunction with the platform specific build environment.
*nmake --
Bell Labs nmake overcomes many limitations inherent in make, providing fully integrated support for viewpathing, dynamic dependency management, and state based execution. Forked into two versions after the AT&T trivestiture, a research version from
AT&T Labs and a supported
Lucent Bell Labs version.
*
Speedy Make XML based make utility, very easy to write.
*
The GNU make manual*
FreeBSD make manual page*
Compiling and Running C++ programs on Linux*
Makefile Tutorial*
GTK Hello World tutorial including HOWTO create Makefiles*
Recursive Make Considered Harmful
