Advanced makefilesby Jennifer Vesperman
In this article, we analyze a fairly complicated makefile. This makefile was captured from actual use in the wild, and sections specific to that project have been removed for this article.
Both the introduction and this advanced article focus on make as a tool for developers. Sysadmins, make can be useful to you, too! As we step through the makefile, think about how the techniques here can be applied to rebuilding a configuration script, or an installation script, or as an auto-updating tool.
Thanks to Mitch Davis for allowing me to use his file. The modified version won't run as presented because I've removed lines, but it will allow me to display various techniques. The original is in frequent use.
# TODO: Add a section for installation # Makefile for (the project) # Version 3.0 # Jennifer Vesperman # 14 August 2001 # # Version 4.0 # Mitch Davis # 10 January 2002
It's always useful to include headers in a makefile and to record the wish list of improvements. My version of the makefile was one of those quick-and-dirty jobs that we find ourselves doing.
# Set up the compiler directories
# (additional directory definitions snipped.)
The paths necessary for compilation are set up as variables. This allows them to be easily changed if the installation is moved--and you can use conditionals and shell functions to change things automatically for different machines. Conditionals and shell functions are discussed in more detail later in this article.
Using a conditional to define a machine-specific variable
ifeq ($(shell uname -n),install) # For compiling on install machine install_d:= /usr/local/jakarta-tomcat-3.2.2/webapps/example endif
Recursively expanded variables
There are two forms of variable. Recursively expanded variables use an "=" between the name and the value and are evaluated at the time the variable is needed. They cannot be defined recursively, as this would create an infinite loop. (make checks for this and forbids this usage.) Functions will be calculated each time make needs the value of the variable.
class_example_d = $(class_d)/example
(refers to a different variable within the definition)
class_d = $(class_d)/example
(recursive definition--refers to itself within its definition)
Simply expanded variables
Simply expanded variables use a ":=" between the name and the value and are evaluated immediately when make encounters the variable. Recursive definition is fine, and the right-hand-side value will be the former value of the variable. Simply expanded variables are a feature of GNU make that may not exist in other versions of make.
class_example_d := $(class_d)/example
class := $(class)/example
classwas defined before this point)
# These exports are for xmlc, which is # a java program which calls javac. export JAVAC:= $(java_h)/bin/javac export JAVA:= $(java_h)/bin/java
Sometimes it's necessary to set environment variables within the makefile, usually when you have a project that must use a specific version of a compiler. Choose your variables carefully--changing the
EDITOR variable will annoy your development team!
# Set up the classpaths for Javac classpath:= \ $(cookie_d)/cookiebuster.jar \ $(example_j) \ $(hsqldb_d)/hsqldb.jar \ $(xmlc_j) \ $(xml_j) \ $(jetty_d)/com.mortbay.jetty.jar # Convert the spaces to colons. This trick is from # the make info file. empty:= space:= $(empty) $(empty) classpath:= $(subst $(space),:,$(classpath))
classpath variable is a standard, simply expanded variable, with its definition split over several lines with the new lines escaped. Mitch then uses a make function to replace the spaces separating paths with colons. He considers this to be a much more readable variable definition than a single line, colon-separated
classpath. Don't use this if you have spaces inside the
make has many useful built-in functions. The syntax of a function call is
$(function arguments). Functions are evaluated when the surrounding construct is evaluated: functions in simply expanded variables are evaluated when make first encounters the variable; functions in recursively expanded variables are evaluated when make needs the value of the variable; functions in rules are evaluated when make runs that part of the rule.
# If there's already a CLASSPATH, put it on the front ifneq ($(CLASSPATH),) classpath:= $(CLASSPATH):$(classpath) endif # Re-export the CLASSPATH. export CLASSPATH:=$(classpath)
Make has conditionals, often used when setting variables. Available conditionals are
ifndef. The else clause is optional, and the arguments may be surrounded by brackets, apostrophes, or quote marks.
In the example, we could have used an
ifdef rather than the
ifneq to determine whether the
classpath environment variable is defined.
The syntax used in this makefile is:
ifeq (arg1, arg2) statement/s else statement/s endif
Pages: 1, 2