Compile the entire program. This should be the default tar-get. This target need not rebuild any documentation files; Info files should normally be included in the distribution, and DVI files should be made only when explicitly asked for.

‘install’

Compile the program and copy the executables, libraries, and so on to the file names where they should reside for actual use. If there is a simple test to verify that a program is properly installed, this target should run that test.

If possible, write the install target rule so that it does not modify anything in the directory where the program was built, provided ‘make all’ has just been done. This is convenient for building the program under one user name and installing it under another.

The commands should create all the directories in which files are to be installed, if they don’t already exist. This includes the directories specified as the values of the variables, prefix and exec_prefix, as well as all sub-directo-ries that are needed. One way to do this is by means of an installdirs target as described below.

Use ‘-’ before any command for installing a man page, so that make will ignore any errors. This is in case there are systems that don’t have the Unix man page documentation system installed.

The way to install info files is to copy them into ‘\$(infodir)’ with \$(INSTALL_DATA) (see Variables for specifying commands), and then run the install-info program if it is present. install-info is a script that edits the Info ‘dir’ file to add or update the menu entry for the given info file; it will be part of the Texinfo package. The following is a sample rule to install an Info file:

$(infodir)/foo.info: foo.info
# There may be a newer info file in . than in srcdir.
   -if test -f foo.info; then d=.; \
     else d=$(srcdir); fi; \
   $(INSTALL_DATA) $$d/foo.info $@; \
# Run install-info only if it exists.
# Use ‘if’ instead of just prepending ‘-’ to the
# line so we notice real errors from install-info.
# We use ‘$(SHELL) -c’ because some shells do not
# fail gracefully when there is an unknown command.
   if $(SHELL) -c ’install-info --version’ \
     >/dev/null 2>&1; then \
     install-info --infodir=$(infodir) $$d/foo.info; \
   else true; fi

‘uninstall’

Delete all the installed files that the ‘install’ target would create (but not the non-installed files such as ‘make all’ would create).

This rule should not modify the directories where compilation is done, only the directories where files are installed.

Delete all files from the current directory that are normally created by building the program. Don’t delete the files that record the configuration. Also preserve files that could be made by building, but normally aren’t because the distribution comes with them. Delete ‘.dvi’ files here if they are not part of the distribution.

‘distclean’

Delete all files from the current directory that are created by configuring or building the program. If you have unpacked the source and built the program without creating any other files, ‘make distclean’ should leave only the files that were in the distribution.

‘mostlyclean’

Like ‘clean’, but may refrain from deleting a few files that people normally don’t want to recompile. For example, the ‘mostlyclean’ target for GCC does not delete ‘libgcc.a’, be-cause recompiling it is rarely necessary and takes a lot of time.

‘maintainer-clean’

Delete almost everything from the current directory that can be reconstructed with this Makefile. This typically includes everything deleted by distclean, plus more: C source files produced by Bison, tags tables, info files, and so on.

The reason we say “almost everything” is that ‘make maintainer-clean’ should not delete ‘configure’ even if ‘configure’ can be remade using a rule in the Makefile. More generally, ‘make maintainer-clean’ should not delete anything that needs to exist in order to run ‘configure’ and then begin to build the program. This is the only exception; maintainer-clean should delete everything else that can be rebuilt.

The ‘maintainer-clean’ is intended to be used by a maintainer of the package, not by ordinary users. You may need special tools to reconstruct some of the files that ‘make maintainer-clean’ deletes. Since these files are normally included in the distribution, we don’t take care to make them easy to reconstruct. If you find you need to unpack the full distribution again, don’t blame us.

To help make users aware of this, maintainer-clean should start with the following two commands.

@echo "This command is intended for maintainers \
        to use;"
@echo "it deletes files that may require special \
        tools to rebuild."

‘TAGS’

Update a tags table for this program.

‘info’

Generate any Info files needed. The best way to write the rules is as follows.
 
info: foo.info

foo.info: foo.texi chap1.texi chap2.texi $(MAKEINFO)
        $(srcdir)/foo.texi

You must define the variable, MAKEINFO, in the Makefile. It should run the makeinfo program which is part of the Texinfo distribution.

‘dvi’

Generate DVI files for all Texinfo documentation. For example:
 
dvi: foo.dvi

foo.dvi: foo.texi chap1.texi chap2.texi $(TEXI2DVI)
        $(srcdir)/foo.texi

You must define the variable, TEXI2DVI, in the Makefile. It should run the program, texi2dvi, which is part of the Texinfo distribution. Alternatively, write just the dependencies, and allow GNU make to provide the command.

‘dist’

Create a distribution tar file for this program. The tar file should be set up so that the file names in the tar file start with a subdirectory name which is the name of the package it is a distribution for. This name can include the version number. For example, the distribution tar file of GCC version 1.40 unpacks into a subdirectory named ‘gcc-1.40’.

The easiest way to do this is to create a subdirectory appropriately named, use ln or cp to install the proper files in it, and then tar that subdirectory. The dist target should explicitly depend on all non-source files that are in the distribution, to make sure they are up to date in the distribution. See section Making Releases” in GNU Coding Standards.

‘check’

Perform self-tests (if any). The user must build the program before running the tests, but need not install the program; you should write the self-tests so that they work when the program is built but not installed.

installcheck

Perform installation tests (if any). The user must build and install the program before running the tests. You should not assume that ‘\$(bindir)’ is in the search path.

installdirs

It’s useful to add a target named ‘installdirs’ to create the directories where files are installed, and their parent directories. There is a script called ‘mkinstalldirs’ which is convenient for this; find it in the Texinfo package.You can use a rule like this:
 
# Make sure all installation directories
# (e.g. $(bindir)) actually exist by
# making them if necessary.
installdirs: mkinstalldirs
        $(srcdir)/mkinstalldirs       $(bindir) $(datadir) \
                                       $(libdir) $(infodir) \
                                       $(mandir)
 
This rule should not modify the directories where compilation is done. It should do nothing but create installation directories.