2.10. make, the GNU Recompiling Tool

make, the GNU recompiling tool, determines automatically which pieces of a large program you need to recompile and then issues commands to recompile them. make conforms to IEEE Standard 1003.2-1992 (POSIX.2) and is compatible with any programming language whose compiler can run with command line input from a shell. make is not limited only to building programs; it can be used for any task in which some files must update automatically whenever associated files change.

To use make, you must write a file (a makefile) that describes the relationships among files in your program and provides commands for updating each file. In a program, typically, the executable file is updated from object files, which are in turn made by compiling source files.

When using make to recompile an executable, the result may change source files in a directory. If you changed a header file, to be safe, you must recompile each source file that includes that header file. Each compilation produces an object file corresponding to the source file. If any source file has been recompiled, all the object files, whether newly made or saved from previous compilations, must be linked together to produce the new executable.

make uses the makefile database and the last modified files to decide which of the other files needs updating. For each of those files, make implements the commands recorded in the data base of the makefile. The makefile has rules which explain how and when to remake certain files that are the targets of a particular rule. A simple makefile rule has the following form:

target... : dependency... command

target is usually the name of a file that a program generates; examples of targets are executable or object files. A target can also be the name of an action to carry out, such as with the clean command (a command that, deletes all files from a build directory before building). A dependency is a file that is used as input to create the target. A target often depends on several files. command is activated by make wnen dependancy has changed. A rule may have more than one command, with each command on its own line. Usually a command is in a rule with dependencies and serves to create a target file if any dependencies change. However, the rule that specifies commands for the target does not require dependencies; for instance, the rule containing the delete command that associates with the target, clean, does not have dependencies. make activates commands on the dependencies to create or to update the target. A rule can also explain how and when to activate a command. A makefile can contain other text besides rules; a simple makefile requires only rules. Rules generally follow the same pattern.

Note that every command line in a makefile must begin with a tab character.

edit : main.o kbd.o command.o display.o insert.o search.o \
                files.o utils.o
        cc -o edit main.o kbd.o command.o display.o insert.o \
                search.o files.o utils.o

main.o : main.c defs.h
        cc -c main.c

kbd.o : kbd.c defs.h command.h
        cc -c kbd.c

command.o : command.c defs.h command.h
        cc -c command.c

display.o : display.c defs.h buffer.h
        cc -c display.c

insert.o : insert.c defs.h buffer.h
        cc -c insert.c

search.o : search.c defs.h buffer.h
        cc -c search.c

files.o : files.c defs.h buffer.h command.h
         cc -c files.c

utils.o : utils.c defs.h
         cc -c utils.c

clean :
        rm edit main.o kbd.o command.o display.o insert.o \
                search.o files.o utils.o