Outline of Class 14: Make

Miscellaneous

• Don't forget the talk by and meeting with Johnny Wong from Iowa State on Wednesday.
• Any questions on assignment 5?
• Any questions on assignment 6? I have verified that this assignment is possible.
• Tony and Omar will be talking about Java security today.
• Aimee and Dan will be talking about something on Friday.
• Any volunteers for next week?

Introduction to make

• Another issue in project managment is deciding which (if any) files need to be recompiled, particularly when there are dependencies between those files.
• For example, if I'm compiling Alpha which includes code for Beta and Gamma, and Beta changes, how do I know that I need to recompile Alpha?
• You may notice fewer of these problems in Java
  • Java's program model helps alleviate some of those problems, since it does dynamic linking.
  • The Java development kit, and particularly javac, also helps eliminate many of those problems, as it uses import statements to identify dependencies.
• Traditionally, make is used to help with these problems. make can automatically determine which files, if any, need to be recompiled and will then recompile for you.
• Even if you won't always need make for use with Java, you will eventually encounter someone else's makefiles, and it helps to be able to read them.
• Traditionally, 223 has required you to purchase a book on make I think you can get by with the man pages.

Basics

• make requires you to store your list of dependencies (and related information) in a make file. This file should be called Makefile or makefile.
  • There are ways to use other files, but I'd recommend against it.
• The primary contents of a makefile are dependencies, and the rules that say how to build a particular object. The general form is

  thing-to-be-made : things-it-depends-upon
  	instructions for making it
  

• When you execute make, it looks at the thing that you're trying to make, determines if any of the things that it depends on have changed (or depend on things that change), and executes the corresponding command if they have.
• For example, to say that my program depends on Game.class, Player.class, Sim.class, and Rules.class and that I execute it with java Sim, I would write

  sim: Game.class Player.class Sim.class Rules.class
  	java Sim
  Game.class: Game.java
  	javac Game.java
  ...
  

  (admittedly, in this example, I'm not actually creating the file sim, but that's okay)
• I would then tell make to recompile as necessary and then execute with
  make sim
• Simlarly, to say that Sim.html depends on Sim.java and that I want to rebuild all the javadoc in order to create Sim.html, I would write:

  Sim.html: Sim.java
  	javadoc -author -version -package *.html
  

Macros

• Often, you'll want to use the same parameters for similar commands (e.g., at present, compile with the -g flag).
• You may also want to ensure that you always use the same version of a compiler (e.g., we have at least three versions of the C compiler: cc, c89, and gcc; you probably want the same one for each .c file you're compiling).
• You may also want to refer to a common set of dependent objects.
• To support these and similar instances, make provides simple "macros" (in effect, they're variables).
• You define a macro with
  NAME = value
• You use a macro with
  $(NAME)
• In my previous example, to ensure that I always used the same flags for javadoc, I might define a JDOCFLAGS macro and always use
  javadoc $(JDOCFLAGS) ...
• make also provides some standard macros
  • $@ is the name of the file that was made (the target)
  • $? is the list of younger objects the target depends on

"Automatic" conversions

• Often, you want to provide standard rules for converting files from one suffix to another suffix.
• For example, we convert .c files to .o files by compiling them with cc (or other C compiler).
• Simlarly, we convert .java files to .class files by compling them with javac.
• make permits you to do define such automatic conversions.
• First, you need to indicate which suffixes are legal with a line like
  .SUFFIXES : .java .class .html .o .c
• For each pair of translatable suffixes you provide a rule (using just the pair of suffixes as the dependent thing)
• Two standard macros are used with automatic conversions
  • $* is the common prefix of target and related file
  • $< is the name of the file that "caused" the action
• For example, to describe the general translation from .java to .class, I might have

  .SUFFIXES : .java .class
  JC = "javac"
  JCFLAGS = ""
  .java.class:
  	$(JC) $(JCFLAGS) $<
  

Standard usage

• make all should make all the primary components of your system (many systems provide a number of programs, this makes all the core ones).
• make should do the same thing as make all (make by itself does the first rule in your file)
• make print should print the key files in the library (or even the recently changed libraries)
• make clean should clean up any object files you have laying around
• make install should install everything in the appropriate place (e.g., if someone were moving your software to a new machine)
• make archive should make an archive of your source code (and Makefile) suitable for transportation elsewhere.