|< Previous||Index||Next >|
Chapter 7: Compiling UNIX software packages
We have many public domain and commercial software packages installed on our systems, which are available to all users. However, users are allowed to download and install small software packages in their own home directory, software usually only useful to them personally.
There are a number of steps needed to install the software.
- Locate and download the source code (which is usually compressed)
- Unpack the source code
- Compile the code
- Install the resulting executable
- Set paths to the installation directory
Of the above steps, probably the most difficult is the compilation stage.
Compiling Source Code
All high-level language code must be converted into a form the computer understands. For example, C language source code is converted into a lower-level language called assembly language. The assembly language code made by the previous stage is then converted into object code which consists of fragments of code which the computer understands directly. The final stage in compiling a program involves linking all of the fragments of object code together into a single executable program.
Performing all of these steps by hand is complicated and beyond the capability of the ordinary user. A number of utilities and tools have been developed for programmers and end-users to simplify these steps.
make and the Makefile
make command allows programmers to manage the compilation of large programs or
groups of programs. It aids in developing large programs by keeping track of
which portions of the entire program have been changed, compiling only those
parts of the program which have changed since the last compile.
make program gets its set of compile rules from a text file
named Makefile which resides in the same directory as the
source files. It contains information on how to compile the software, e.g. the
optimization level, whether to include debugging information in the executable. It
also contains information on where to install the compiled binaries
(executables), manual pages, data files, dependent library files, configuration
Some packages require you to edit the Makefile by hand to set the final installation directory and any other parameters. However, many packages are now being distributed with the GNU configure utility.
As the number of UNIX variants increased, it became harder to write programs which could run on all variants. Developers frequently did not have access to every system, and the characteristics of some systems changed from version to version. The GNU configure and build system simplifies the building of programs distributed as source code. All programs are built using a simple, standardised, two step process. The program builder need not install any special tools in order to build the program.
configure shell script attempts to guess correct values for
various system-dependent variables used during compilation. It uses those values
to create a Makefile in each directory of the package.
The simplest way to compile a package is:
cdto the directory containing the package's source code.
./configureto configure the package for your system.
maketo compile the package.
make installto install the programs and any data files and documentation.
- Optionally, type
make cleanto remove the program binaries and object files from the source code directory
The configure utility supports a wide variety of options. You can usually use
--help option to get a list of interesting options for a particular
The only generic options you are likely to use are the
--exec-prefix options. These options are used to specify the
The directory named by the
--prefix option will hold machine independent
files such as documentation, data and configuration files.
The directory named by the
--exec-prefix option, (which is normally
a subdirectory of the --prefix directory), will hold machine dependent files
such as executables.
7.1 Downloading source code
For this example, we will download a piece of free software that converts between different units of measurements.
First create a download directory and go into that directory using cd:
$ cd download
Now use the
wget command to download the file. The
downloads a file from a remote location (like the internet).
7.2 Extracting the source code
Now, let's see what we downloaded:
As you can see, the filename ends in tar.gz. The "tar" part of the file means that this file contains a group of files and the "gz" part means that it is compressed using the gzip format
tar command, we can extract all of the compressed files:
Again, list the contents of the download directory, then go to the units-1.87 sub-directory.
7.3 Configuring and creating the Makefile
The first thing to do is carefully read the README and INSTALL
text files (use the
less command). These contain important information
on how to compile and run the software.
The units package uses the GNU configure system to compile the source code. We will need to specify the installation directory, since the default will be the main system area, which you are not allowed to write to. Instead, we will install the software to a directory within your home directory.
Note: The $HOME variable is an example of an environment variable.
The value of $HOME is the path to your home directory. Just type
$ echo $HOME
to show the contents of this variable. We will learn more about environment variables in the next chapter.
If configure has run correctly, it will have created a Makefile with all necessary
options. Make sure that configure did not output any errors. You can view the Makefile if you wish (use the
but do not edit the contents of it.
7.4 Building the package
Now you can go ahead and build the package by running the
After a minute or two (depending on the speed of the computer), the executables will be created. If you don't see any errors on the screen, then the software has most likely compiled properly. If everything is okay, you can now install the package.
This will install the files into the ~/units187 directory
that you specified with
7.5 Running the software
You are now ready to run the software (assuming everything worked).
If you list the contents of the units directory, you will see a number of subdirectories.
|bin||The binary executables|
To run the program, change to the bin directory and type
As an example, convert 6 feet to metres.
You want: metres
If you get the answer 1.8288, congratulations, it worked.
To view what units it can convert between, view the data file in the share directory (the list is quite comprehensive).
To read the full documentation, change into the info directory (it is a subdirectory of share) and type
7.6 Stripping unnecessary code
When a piece of software is being developed, it is useful for the programmer to include debugging information with the resulting executable. This way, if there are problems encountered when running the executable, the programmer can load the executable into a debugging software package and track down any software bugs.
This is useful for the programmer, but unnecessary for the user. We can assume that the package, once finished and available for download has already been tested and debugged. However, when we compiled the software above, debugging information was still compiled into the final executable. Since it is unlikey that we are going to need this debugging information, we can strip it out of the final executable. One of the advantages of this is a much smaller executable, which should run slightly faster.
What we are going to do is look at the before and after size of the binary file. First change into the bin directory of the units installation directory.
$ ls -l
As you can see, the file is ~100 kbytes in size. You can get more information
on the type of the file by using the
units: ELF 32-bit LSB executable, Intel 80386, version 1, dynamically linked (uses shared libs), not stripped
To strip all the debug and line numbering information out of the binary file,
$ ls -l
As you can see, the file is now ~40 kbytes - a third of its original size. Two thirds of the binary file was debug code !!!
Check the file information again.
units: ELF 32-bit LSB executable, Intel 80386, version 1, dynamically linked (uses shared libs), stripped
Hint: You can use the make command to install pre-stripped copies
of all the binary files when you install the package. Instead of typing
||Configures the software to be installed in /path/to/install/directory|
||Builds the source code and must be run in a directory containing a Makefile|
||Install the software into the prefix specified with ./configure|
||Strip unneeded symbols from executable|
||Strip unneeded symbols from binaries and install the software into the prefix specified with ./configure|
||Download the file at URL|
||Extract files from a .tar.gz file archive|
|< Previous||Index||Next >|