Most projects have many different files, libraries, and programs. The UNIX 'make' program helps you rebuild the program when some of the files are changed. It calculates precisely the smallest number operations needed to reconstruct a new version and carries them out in the correct order.

The 'make' program is normally controlled by a file called 'Makefile'. Think of a Makefile as a computerized cook-book:

---

 		popcorn: raw_popcorn

 			put raw_popcorn in microwave

 			push popcorn button and wait

 			push open button and remove popcorn

 		clean:

 			wipe inside of microwave

 			put empty bag in trash

 		snack: popcorn

 			eat popcorn

---

The command

 		make popcorn

will check to see that there is some raw_popcorn and if so puts it in the oven and pushes the button for us.

If we try the command

 		make snack

the make program first looks to see if we have popcorn, and if needed makes it for us... then we eat the popcorn. Notice that the recipes can be in any order and the make program selects the right ones to follow.

Syntax

A makefile is made of Recipes and Actions:


(Recipe):

 	thing_to_be_made : raw_materials

 	<TAB>	step to make the thing from the raw materials

 	<TAB>	step to make the thing from the raw materials

The thing_to_be_made is called the target of the rule(recipe) and the raw_materials are called the input.
(Action):

 	something_to_do:

 	<TAB>	step to do it

 	<TAB>	step to do it

Notice the <TAB> character. This must be the real Tab character. Spaces do not work.

Example 1

Suppose we have a source code file called "memo.cpp" file that must be compiled into an executable memo. Here is a complete Makefile for this:

---

 memo : memo.cpp

 	g++ -w -O -o memo memo.cpp

---

The "-w -O" requests that compilation gives few warning messages and try to optimize the program.

Example 2

Suppose are memo program uses a function called remind and that the code for this is a file called remind.cpp which is included in memo.cpp:

---

 memo : memo.cpp reminder.cpp

 	g++ -w -O -o memo memo.cpp

---

Example 3

However reminder.cpp is a large file and takes a long time to compile. Recompiling it each time is wasteful so we create a header file reminder.h and need to recipes, like this:

---

 memo : memo.cpp reminder.h

 	g++ -w -O -o memo memo.cpp reminder.o

 reminder.o : reminder.cpp reminder.h

 	g++ -w -O -c reminder.cpp

---

Advanced Makefiles

The target doesn't have to be a real file. For example

 clean:

  	rm *.o

means that the command make clean removes all the .o files.

You can define a short name for something:

 	CC=g++ -w -o

means that $(CC) can be used to replace g++ -w -o in any command. Note. Error in Horstmann: When CC is in a command it has to be written $(CC) not CC.

We can generate large numbers of recipes by using implicit rules. They are hard to understand but easy to use:

 .cpp.o

  	$(CC) -c $<

has the effect of creating an infinite number of similar rules: they will take any .cpp file and make a .o file from it.

See Also

For more information see my local documentation in http://www.csci.csusb.edu/dick/doc/: [ make.html ] [ makefile.FAQ ] [ make.man ]

BNF Syntax

1. makefile::= # recipe. Any number of recipes.
2. recipe::= header # step. A recipe has one header and any number of steps.
3. header::= target colon # input endl. A header has a target, a colon, and a number of inputs on one line.
4. step::=htab Unix_command endl. A step must be prefixed by a tab character and be on one line.
5. target::= identifier.
6. colon::=":".
7. input::=identifier.
8. endl::=end of a line, tap the enter key!.
9. htab::=Horizontal tab, tap the key marked Tab.
10. Unix_command::=Any command that a UNIX shell will execute.

. . . . . . . . . ( end of section Make) <<Contents | End>>

Abreviations