If you’ve used any flavour of Unix for development, you’ve probably installed software from source with this magic incantation:
I know I’ve typed it a lot, but in my early days using Linux I didn’t really understand what it meant, I just knew that if I wanted to install software this was the spell to recite.
Recently I’ve been building my own Unix tools, and I wanted to tap into this standard install process; not only is it familiar to many Unix users, it’s also a great starting point for building a package for Homebrew and the various Linux and BSD package managers. It was time to dig into the Unix Grimoire and find out what the incantation does.
What does all of this do
There are three distinct steps in this process:
1. Configure the software
configure script is responsible for getting ready to build the software on your specific system. It makes sure all of the dependencies for the rest of the build and install process are available, and finds out whatever it needs to know to use those dependencies.
Unix programs are often written in C, so we’ll usually need a C compiler to build them. In these cases the
configure script will establish that your system does indeed have a C compiler, and find out what it’s called and where to find it.
2. Build the software
configure has done its job, we can invoke
make to build the software. This runs a series of tasks defined in a
Makefile to build the finished program from its source code.
The tarball you download usually doesn’t include a finished
Makefile. Instead it comes with a template called
Makefile.in and the
configure script produces a customised
Makefile specific to your system.
3. Install the software
Now that the software is built and ready to run, the files can be copied to their final destinations. The
make install command will copy the built program, and its libraries and documentation, to the correct locations.
This usually means that the program’s binary will be copied to a directory on your
PATH, the program’s manual page will be copied to a directory on your
MANPATH, and any other files it depends on will be safely stored in the appropriate place.
Since the install step is also defined in the
Makefile, where the software is installed can change based on options passed to the
configure script, or things the
configure script discovered about your system.
Depending on where the software is being installed, you might need escalated permissions for this step so you can copy files to system directories. Using
sudo will often do the trick.
Where do these scripts come from
All of this works because a
configure script examines your system, and uses the information it finds to convert a
Makefile.in template into a
Makefile, but where do the
configure script and the
Makefile.in template come from?
If you’ve ever opened up a
configure script, or associated
Makefile.in, you will have seen that they are thousands of lines of dense shell script. Sometimes these supporting scripts are longer than the source code of the program they install.
Even starting from an existing
configure script, it would be very daunting to manually construct one. Don’t worry, though: these scripts aren’t built by hand.
Programs that are built in this way have usually been packaged using a suite of programs collectively referred to as autotools. This suite includes
automake, and many other programs, all of which work together to make the life of a software maintainer significantly easier. The end user doesn’t see these tools, but they take the pain out of setting up an install process that will run consistently on many different flavours of Unix.