Class 12: Simple Project Management with Make

Held: Wednesday, 22 September 2004

Summary: Today we review the wonders of Make, a tool for handlind dependencies and recompilation.

Related Pages:

• EBoard.
• Examples.
• info make

Notes:

• Are there questions on BugWorld?

Overview:

• The problems Make addresses
• Make basics
• Variables in Make
• Standard Make targets
• Advanced make

Problems

• When building large projects,
  • There are often significant dependencies to address (we must compile x before y, we must compile q before x).
  • Some "actions" involve multiple steps (to install a library, we must create the appropriate library directory, combine the .o files into a library, and copy the library to the appropriate directory)
• Make was designed to handle these, and related, issues.
• Note that the Java compiler handles some of the dependency issues automatically. Other compilers don't.
• Note that Make was designed with C in mind, so some C stuff is automated.

Make Basics

• The guidelines/instructions for Make traditionally go in a file called Makefile.
• The simplest entry in a Makefile has the following form:

  target: things-it-depends-on
  	instruction1
  	instruction2
  

• Warning: The instructions must be preceded by tabs, not by spaces.
• Note that these lines say a few different, but related, things:
  • In order to build target, I must first build things-it-depends-on
  • The commands for building target are instruction1 and instruction2, which must be executed in sequence.
  • If any of the things-it-depends-on changes, target should be rebuilt (by executing those instructions).
• For example, to build the jar file stuff.jar, I might need Stu.class and FF.class. I would express this as

  stuff.jar: Stu.class FF.class
  	jar -c stuff.jar Stu.class FF.class
  

• If the compilation of Stu.class depends on Stu.java and Art.class, I might write

  Stu.class: Stu.java Art.class
  	jc Stu.java
  

• Once you've written your makefile, you check dependencies and update a file with

  	make target
  

• If you want to make everything in your file, add something like the following at the beginning of your file

  all: target1 target2 target3 
  

• You can now type

  make all
  

• By default, Make applies the first rule it sees. Hence, you can also type just

  make
  

• Note that Make follows dependency chains.
• Comments in Make are preceded by a pound sign (hash mark): #

Variables

• At times, you will repeat text from rule to rule.
  • You may have multiple files that depend on the same file.
  • You may have similar flags to a compiler.
  • You may have the full path name for a compiler.
• Make's variables help you handle these issues.
• The format for a variable definition is

  VARIABLE = DEFINITION
  

• For example,

  JAVAC = /opt/IBMJava2-142/bin/javac
  

• From then on, you refer to a variable as $(VARAIBLE).
• For example,

  Stu.class: Stu.java Art.class
  	$(JAVAC) Stu.java
  

• Custom is that you name variables with all upper-case letters.
• If you put site-specific variables at the top of your Makefile, it becomes easier for others to customize your Makefile for their own site.
  • For example, the Java compiler is often in different places.
• A good custom is to define the compiler variable in terms of three variables:
  • The location of the compiler
  • Site-specific flags
  • Project-specific flags
• For example

  ############################################################
  # SITE SPECIFIC ENTRIES #
  #########################
  
  # Change the following to the path to your Javadoc program
  JAVADOC = /opt/IBMJava2-142/bin/javadoc
  
  # Change the following to the standard location for documentation
  DOCDIR = /home/rebelsky/Web/Courses/CS223/2004F/Examples/make/doc
  
  ############################################################
  # SITE SPECIFIC ENTRIES #
  #########################
  
  # Standard flags for Javadoc
  JDFLAGS = -d $(DOCDIR) -author -version
  
  # Build Javadoc
  JD = $(JAVADOC) $(JDFLAGS)
  
  # The standard Java files
  JAVA_FILES = Stu.java Art.java
  doc: $(JAVA_FILES)
  	$(JD) $(JAVA_FILES)
  

Standard Targets

• all: everything
• build: compile everything and shove in an executable.
• test: test your compiled executable
• install: copy the executable to the standard destination directory
• clean: remove the stuff built along the way

Advanced Make

• Variable $< refers to the target. (Useful in some general commands)
• Variables $* refers to the prefix of the target (everything up to the dot)
• For general rules (always turn .java into .class)
  • Add .SUFFIXES: suffixes
  • Add rule with target .suffix.suffix