The Makefile
is the key to the build process. In its simplest
form, a Makefile is a script for compiling or building the "binaries",
the executable portions of a package. The Makefile can also provide a
means of updating a software package without having to recompile every
single source file in it, but that is a different story (or a different
article).
At some point, the Makefile launches cc
or gcc
. This
is actually a preprocessor, a C (or C++) compiler, and a linker, invoked
in that order. This process converts the source into the binaries, the
actual executables.
Invoking make usually involves just typing make. This generally builds all the necessary executable files for the package in question. However, make can also do other tasks, such as installing the files in their proper directories (make install) and removing stale object files (make clean). Running make -n permits previewing the build process, as it prints out all the commands that would be triggered by a make, without actually executing them.
Only the simplest software uses a generic Makefile. More complex
installations require tailoring the Makefile according to the location
of libraries, include files, and resources on your particular machine.
This is especially the case when the build needs the X11
libraries to install. Imake and xmkmf accomplish this
task.
An Imakefile
is, to quote the man page, a "template"
Makefile. The imake utility constructs a Makefile appropriate for your
system from the Imakefile. In almost all cases, however, you would run
xmkmf, a shell script that invokes imake, a front end for it.
Check the README or INSTALL file included in the software archive for
specific instructions. (If, after dearchiving the source files, there
is an Imake
file present in the base directory, this is a dead
giveaway that xmkmf should be run.) Read the Imake
and
xmkmf
man pages for a more detailed analysis of the procedure.
Be aware that xmkmf
and make
may need to be invoked as
root, especially when doing a make install to move the binaries
over to the /usr/bin
or /usr/local/bin
directories.
Using make as an ordinary user without root privileges will likely
result in write access denied error messages because you lack
write permission to system directories. Check also that the binaries
created have the proper execute permissions for you and any other
appropriate users.
Invoking xmkmf uses the Imake
file to build a new
Makefile appropriate for your system. You would normally invoke
xmkmf with the -a argument, to automatically do a
make Makefiles, make includes, and make depend. This
sets the variables and defines the library locations for the compiler
and linker. Sometimes, there will be no Imake
file, instead
there will be an INSTALL
or configure
script that will
accomplish this purpose. Note that if you run configure
, it
should be invoked as ./configure to ensure that the correct
configure
script in the current directory is called. In most
cases, the README
file included with the distribution will
explain the install procedure.
It is usually a good idea to visually inspect the Makefile
that
xmkmf
or one of the install scripts builds. The Makefile will
normally be correct for your system, but you may occasionally be
required to "tweak" it or correct errors manually.
Installing the freshly built binaries into the appropriate system directories
is usually a matter of running make install as root. The usual
directories for system-wide binaries on modern Linux distributions are
/usr/bin
, /usr/X11R6/bin
, and /usr/local/bin
. The
preferred directory for new packages is /usr/local/bin
, as this will
keep separate binaries not part of the original Linux installation.
Packages originally targeted for commercial versions of UNIX may attempt
to install in the /opt
or other unfamiliar directory. This will,
of course, result in an installation error if the intended installation
directory does not exist. The simplest way to deal with this is to
create, as root, an /opt
directory, let the package install
there, then add that directory to the PATH
environmental
variable. Alternatively, you may create symbolic links to the
/usr/local/bin
directory.
Your general installation procedure will therefore be:
README
file and other applicable docs.INSTALL
or configure
script.Makefile
.
Notes:
gcc
in the standard Makefile
included or created
in the package you are installing. Some of these common options are
-O2, -fomit-frame-pointer, -funroll-loops,
and -mpentium (if you are running a Pentium cpu). Use caution
and good sense when modifying a Makefile
!
/coll
and /pack
directories. You may
find it necessary to download the Pack-Collection from the
above site should you ever run across one of these distributions.