SE 3800, Note 2c
Makefiles

Makefile Review

• make: Unix utility to construct projects
• See todo example
• targets, dependencies, commands
  • dependencies: an implied tree
    • [give tree view of makefile]
  • hard tabs before commands!
  • show: update task.cpp, see what rebuilt
  • show: update task.h, see what rebuilt
• How to organize large projects?
  • directories for libraries, link libraries
  • obvious, but bad choice: subdirectories for .h, .cpp files
  • problem: easiest to put code in same folder with the makefile, so subdirectories often require separate makefiles for each
• makedepend, fastdep: Unix utilities to generate makefiles from sources - great for larger projects
• can have multi-line commands - tab before each line
  • Makefile for cube example
• Note also the all target: make all
  • First target executed by default; make does the same
• clean target: traditional for removing all build files
• Key to understanding Makefiles: collections of dependencies
  • Core element:

    a: b c
            command
    

    means
    • "execute command whenever b or c is newer than a"
    • presumably the command recreates a
  • given a: b c, make first recursively builds b
    • Suppose there is a rule

      b: d e f
              command to (re)build b
      

      in the file. Make checks to see if d, e, or f are newer than b. If any one of them is, then the command to rebuild b is executed. If b is newer than all of those, the command is not executed.
    • If the command to build/rebuild b fails (returns a non-zero status code), make displays an error and halts.
    • If b doesn't exist and there is no rule for it, make exits with a message like "cannot build b".
    • If there is no rule for b, but b already exists, make moves on to the next dependency (in this case, c)
  • Make then repeats the process for c, attempting to build that if necessary and failing if c's build fails (including the case in which c doesn't exist and there is no rule).
  • Once the build of b and c succeed, make now compares the last modification dates of those files against the last modification date of file a; if either is newer, it executes the command that rebuilds a.
• Beauty of make: this one simple rule - check dependencies and rebuild them, then rebuild the target if any dependency is newer - covers a very wide variety of build steps.
• Commands can be anything that is in your $PATH, so not limited to standard compilers.
• The result: make works for any compiler/programming language as well as any tool that requires rebuilding files when other files change
  • It is very useful for publishing materials, web site maintenance, etc.

Simplifying Makefiles

• First rule of optimization: don't
• But if insist...
• Can add constants:

  CPPFLAGS=-std=c++14 -Wall --coverage
  
  cube_test.o: cube.h cube_test.cpp
  	g++ $(CPPFLAGS) -c cube_test.cpp
  

• Default rules: has built in rules for converting .cpp to .o:

  stack.o: stack.h list.h stack.cpp
  

  Automatically executes

          $(CXX) -c $(CPPFLAGS)
  

  on the files (so the choice CPPFLAGS above was not accidental!), giving the command

          g++ -c -std=c++14 -Wall --coverage stack.cpp
  

A shorter file (untested!)

---

# makefile for cube code

CPPFLAGS=-std=c++14 -Wall --coverage

all: cube cube_test

cube.o: cube.h cube.cpp

cube_test.o: cube.h cube_test.cpp

main.o: cube.h main.cpp

cube: cube.o main.o

cube_test: cube.o cube_test.o
	g++ -pthread $(CPPFLAGS) cube.o cube_test.o -lgtest_main -lgtest -lpthread -o cube_test

coverage: cube_test
	mkdir -p code_coverage_report
	./cube_test
	lcov --directory ./ --capture --output-file ./code_coverage.info -rc lcov_branch_coverage=1
	genhtml code_coverage.info --branch-coverage --output-directory ./code_coverage_report/

clean:
	rm -f *.o *.gcda *.gcno code_coverage.info cube cube_test 
        rm -rf code_coverage_report

---

Alternative Build Environments

• make: generally portable, not standardized in details
  • But gnumake (the one that comes with g++) is very available
  • VisualStudio, many other C++ build envronments use some variant of make
• ant: implemented in Java, very standardized
  • ant_demo.xml: ant printmessage
  • a "real" script: jardemo.xml
  • Why not using? Challenging to read, write
• maven: yet another make-like tool, but this one uses more implicit rules
  • great when they work...