Today most software packages on a Mac are installed by downloading a DMG file. A DMG file is a disk image file. When you double-click it, the DMG file mounts a virtual disk which appears as an icon on your Desktop. You install the software by either dragging the application file to the Applications folder or double-clicking on a PKG file. When you double-click a PKG file, the OS X Installer will open a window to guide you through the installation.
Using a DMG file is by far the most common way of installing software on a Mac. However, if you have Xcode installed on your computer you can compile almost any source code and install it on your Mac. The process is a little complicated and there are a number of steps needed to install the software. If you don't have Xcode installed on your computer or you don't think you'll need to compile your own source code you can skip this chapter.
Of the above steps, probably the most difficult is the compilation stage.
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 are fragments of code which the computer understands directly. The final stage in compiling a program involves linking the object code to code libraries which contain certain built-in functions. This final stage produces an executable program.
To do all these steps by hand is complicated so a number of utilities and tools have been developed for programmers and end-users to simplify these steps.
The make command allows programmers to manage 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.
The make program gets its set of compile rules from a text file called 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 info in the executable. It also contains information on where to install the finished compiled binaries (executables), manual pages, data files, dependent library files, configuration files, etc.
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, standardized, two step process. The program builder need not install any special tools in order to build the program.
The 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:
The configure utility supports a wide variety of options. You can usually use the --help option to get a list of interesting options for a particular configure script.
The only generic options you are likely to use are the --prefix and --exec-prefix options. These options are used to specify the installation directories.
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.
For this example, we will download a piece of free software that converts between different units of measurements.
First create a directory for download
$ mkdir installtest
Download the software here and save it to your new download directory.
Go into your installtest directory and list the contents.
$ cd installtest
$ ls -l
As you can see, the filename ends in zip.
First unzip the file using the unzip command.
$ unzip units-1.74.zip
Again, list the contents of the installtest directory, then go to the units-1.74 sub-directory.
$ cd units-1.74
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 will not have write permissions for. We need to create an install directory in your home directory.
$ mkdir ~/units174
Then run the configure utility setting the installation path to this.
$ ./configure --prefix=$HOME/units174
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 a later chapter.
If configure has run correctly, it will have created a Makefile with all necessary options. You can view the Makefile if you wish (use the less command), but do not edit the contents of this.
Now you can go ahead and build the package by running the make command.
$ make
After a minute or two (depending on the speed of the computer), the executables will be created. You can check to see everything compiled successfully by typing
$ make check
If everything is okay, you can now install the package.
$ make install
This will install the files into the ~/units174 directory you created earlier.
You are now ready to run the software (assuming everything worked).
$ cd ~/units174
If you list the contents of the units directory, you will see a number of subdirectories.
| bin | The binary executables |
| info | GNU info formatted documentation |
| man | Man pages |
| share | Shared data files |
To run the program, change to the bin directory and type
$ ./units
As an example, convert 6 feet to meters.
You have: 6 feet
You want: meters
* 1.8288
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 and type
$ info --file=units.info
When a piece of software is being developed, it is useful for the programmer to include debugging information into 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 unlikely 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.
$ cd ~/units174/bin
$ ls -l
Note the size of the units program file.
To strip all the debug and line numbering information out of the binary file, use the strip command
$ strip units
$ ls -l
As you can see, the file is now much smaller.
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 make install, simply type make install-strip
Adapted for Mac OS X by Shane Burns from a tutorial by M.Stonebank@surrey.ac.uk, © October 2001