If the source consists of a single source file (e.g. foo.c, it can be compiled straightforward with
gcc -o foo foo.c
However, most applications consist of several / many source (and header) files. Moreover, there are sometimes complicated dependencies as to which files need to be re-compiled if some file has been edited. For this reason, there is a utility called make that allows to build large and complex applications simply by specifying appropriate rules in a Makefile, and then invoking make.
If there is no Makefile, but a file named Makefile.in, then there is usually also a file named configure. Read Section 9> to learn how to create a Makefile from these files.
A Makefile contains a number of rules. Each of these rules has on the first line a target (that should be made by the rule), followed by a colon, optionally followed by a list of dependencies (that are required to make the target). Optionally, the next line(s) contain the (shell) command(s) to make the target. Each of these lines must start with a tab — not some spaces.
If make is invoked, you can give any target in the makefile as argument. The default target is "all" (that is, a target named "all", not all targets). Also, by default make will use a file named Makefile in the current directory. Thus, we can create a file Makefile with two targets "all" and "foo" like this:
all: foo foo: foo.c gcc -c foo foo.c
We can then invoke make like this:
bash$ make gcc -c foo foo.c bash$ make foo make: `foo' is up to date. bash$ make nonexistent_target make: *** No rule to make target `nonexistent_target'. Stop.(The first command will make "all", which will also cause "foo" to be made (because the rule for "all" requires "foo"). The second command will do nothing, because "foo" has just been made, and "foo.c" has not been changed since. The third command fails because we have no rule for "nonexistent_target" in our example Makefile).
Commonly, a Makefile has rules for targets like
Default target, usually compiles the application.
Installs the compiled application, and eventually manpages or other files required to use the application.
Uninstalls the application.
Removes intermediary files generated during the compilation of the application.
Removes anything generated during the compilation, to start allow a fresh start.