Intro
This makefile will always run. The default target is some_binary
, because it is first.
some_binary:
echo "nothing"
Intro
This file will make some_binary
the first time, and the second time notice it’s already made, resulting in make: 'some_binary' is up to date.
some_binary:
touch some_binary
Intro
Alternative syntax: same line
some_binary: ; touch some_binary
Intro
\ gives us multilines
some_binary:
touch \
some_binary
Intro
Will call other.txt target if it is newer than the some_binary
file, or it doesn’t exist. It will call the other.txt rule first.
some_binary: other.txt
touch some_binary
other.txt:
touch other.txt
Intro
This will always make both targets, because some_binary
depends on other.txt, which is never created.
some_binary: other.txt
touch some_binary
other.txt:
echo "nothing"
Intro
“clean” is not a special word. If there’s a file called clean that is made, then “make clean” won’t have to do anything. Similarly, if the clean file is older than the some_binary
file, the clean rule will not be called.
some_binary: clean
touch some_binary
clean:
touch clean
actual_clean:
rm some_binary
rm clean
# Adding PHONY to a target will prevent make from confusing the phony target with a file name.
# In this example, if clean is created, make clean will still be run.
# PHONY is great to use, but I'll skip it in the rest of the examples for simplicity.
some_binary:
touch some_binary
touch clean
.PHONY: clean
clean:
rm some_binary
rm clean
2.4:
Variables can only be strings. Here’s an example:
files = file1 file2
some_binary: $(files)
echo "Look at this variable: " $(files)
touch some_binary
file1:
touch file1
file2:
touch file2
clean:
rm file1 file2 some_binary
Here’s a blah.c file that some examples below require
#include<stdio.h>
#include <string.h>
int main()
{
#printf("hello there\n");
#return 0;
}
2.5:
Example requires: blah.c
If we have a target that is a “.c” file, there is an implicit command that will be “cc -c file.c -o file.o”.
# Implicit command of: "cc -c blah.c -o blah.o"
# Note: 1) Do not put a comment inside of the blah.o rule; the implicit rule will not run!
# 2) If there is no blah.c file, the implicit rule will not run and will not complain.
blah.o:
clean:
rm blah.o
4.1
Print literal ‘$’
some_binary:
echo $$
4.2
We can use wildcards in the target, prerequisites, or commands.
Valid wildcards are *, ?, [...]
some_binary: *.c
# create the binary
*.c:
touch f1.c
touch f2.c
clean:
rm *.c
4.2.3
We CANNOT use wildcards in other places, like variable declarations or function arguments
Use the wildcard function instead.
wrong = *.o # Wrong
objects := $(wildcard *.c) # Right
some_binary:
touch f1.c
touch f2.c
echo $(wrong)
echo $(objects)
clean:
rm *.c
4.3.2
Use vpath to specify where some set of prerequisites exist. The format is vpath <pattern> <directories, space/colon seperated>
<pattern>
can have a %
, which matches any zero or more characters.
You can also do this globallyish with the variable VPATH
vpath %.h ../headers ../other-directory
some_binary: ../headers blah.h
touch some_binary
../headers:
mkdir ../headers
blah.h:
touch ../headers/blah.h
clean:
rm -rf ../headers
rm some_binary
4.4
Making multiple targets? Make a phony ‘all’!
Note here PHONY is after all, because the target is seen as ‘all’ instead of PHONY,
giving better error dumps.
all: one two three
.PHONY: all
one:
touch one
two:
touch two
three:
touch three
clean:
rm one two three
4.8
Multiple Targets: the rule will be run for each target
$@
is a automatic variable that contains the target name.
all: f1.o f2.o
f1.o f2.o:
echo $@
# Equivalent to:
# f1.o
# echo $@
# f2.o
# echo $@
clean:
rm *.c
4.8
Multiple Targets: We can use the wildcard % in targets, that captures zero or more of any character
Note
1) We do not use *.o, because that is just the string *.o, which might be useful in the commands,
but is only one target and does not expand.
2) PHONY is needed because otherwise make will create an automatic rule of “cc all.o f1.o f2.o -o all
TODO why was this not a problem when I didn’t use the % wildcard?
all: f1.o f2.o
.PHONY: all
%.o:
echo $@
clean:
rm *.c
4.10
Static Pattern Rules: each .o file has a prereq of the corresponding .c name
Run “make init” first to make the .c files
objects = foo.o bar.o
all: $(objects)
# targets ...: target-pattern: prereq-patterns ...
$(objects): %.o: %.c
echo "make file" $@ "with prereqs" $<
init:
touch foo.c
touch bar.c
clean:
rm foo.c bar.c
4.10
filter can be used in Static pattern rules to match the correct files
Run “make init” first to make the necessary files
files = foo.elc bar.o lose.o
src_files = foo.el bar.c lose.c
all: $(files)
$(filter %.o,$(files)): %.o: %.c
echo "target: " $@ "prereq: " $<
$(filter %.elc,$(files)): %.elc: %.el
echo "target: " $@ "prereq: " $<
init:
touch $(src_files)
clean:
rm $(src_files)
4.11
Double-Colon Rules are rarely used, but allow the same target to run commands from multiple targets.
If these were single colons, an warning would be printed and only the second set of commands would run.
all: blah
blah::
echo "hello"
blah::
echo "hello again"
clean:
rm $(src_files)
4.12
Example requires: blah.c
Generating prereqs automatically
This makes one small makefile per source file
Notes:
1) , with escaping. We use it to make a temporary file, that doesn’t interfere with others if there is some parallel builds going on.
2) cc -MM outputs a makefile line. This is the magic that generates prereqs automatically, by looking at the code itself
3) The purpose of the sed command is to translate (for example):
main.o : main.c defs.h
into:
main.o main.d : main.c defs.h
4) Running make clean
will rerun the rm -f … rule because the include line wants to include an up to date version of the file. There is such a target that updates it, so it runs that rule before including the file.
all: blah.d
clean:
rm blah.d
%.d: %.c
rm -f $@; \
$(CC) -MM $(CPPFLAGS) $< > $@.$$$$; \
sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
rm -f $@.$$$$
sources = blah.c
include $(sources:.c=.d)
5.1
Add an @ before a command to stop it from being printed
You can also run make with -s to add an @ before each line
all:
@echo "This make line will not be printed"
echo "But this will"
5.2
Each command is run in a new shell (or at least the affect is as such)
all:
cd ..
# The cd above does not affect this line, because each command is effectively run in a new shell
echo `pwd`
# This cd command affects the next because they are on the same line
cd ..;echo `pwd`
# Same as above
cd ..; \
echo `pwd`
5.2
Note only: the default shell is /bin/sh. You can change this by changing the variable SHELL
5.4
Make stops running a rule (and will propogate back to prerequisites) if a command returns a nonzero exit status.
DELETE_ON_ERROR
will delete the target of a rule if the rule fails in this manner. This will happen for all targets, not just the one it is before like PHONY. It’s a good idea to always use this, even though make does not for historical reasons.
Add “-k” when running make to continue running even in the face of errors. Helpful if you want to see all the errors of Make at once.
.DELETE_ON_ERROR:
all: one two
one:
touch one
false
two:
touch two
false
5.4
Add a “-“ before a command to suppress the error
Add “-i” to make to have this happen for every command.
one:
false
touch one
5.5
Note only: If you ctrl+c make, it will delete the newer targets it just made.
5.6
Recursively call a makefile. Use the special $(MAKE) instead of “make”
because it will pass the make flags for you and won’t itself be affected by them.
new_contents = "\
hello:\\n\
\\ttouch inside_file"
all:
mkdir -p subdir
echo $(new_contents) | sed -e 's/^ //' > subdir/makefile
cd subdir && $(MAKE)
clean:
rm -rf subdir
5.6
The export directive takes a variable and makes it accessible to sub-make commands.
In this example, “cooly” is exported such that the makefile in subdir can use it.
Recursively call a makefile. Use the special $(MAKE) instead of “make”
because it will pass the make flags for you and won’t itself be affected by them.
Note: export has the same syntax as sh, but it they aren’t related (although similar in function)
new_contents = "\
hello:\\n\
\\techo \$$(cooly)"
all:
mkdir -p subdir
echo $(new_contents) | sed -e 's/^ //' > subdir/makefile
@echo "---MAKEFILE CONTENTS---"
@cd subdir && cat makefile
@echo "---END mAKEFILE CONTENTS---"
cd subdir && $(MAKE)
# Note that variables and exports. They are set/affected globally.
cooly = "The subdirectory can see me!"
export cooly
# This would nullify the line above: unexport cooly
clean:
rm -rf subdir
5.6
You need to export variables to have them run in the shell as well.
one=this will only work locally
export two=we can run subcommands with this
.PHONY: all
all:
@echo $(one)
@echo $$one
@echo $(two)
@echo $$two
5.6
EXPORT_ALL_VARIABLES
does what you might expect
.EXPORT_ALL_VARIABLES:
new_contents = "\
hello:\\n\
\\techo \$$(cooly)"
cooly = "The subdirectory can see me!"
# This would nullify the line above: unexport cooly
all:
mkdir -p subdir
echo $(new_contents) | sed -e 's/^ //' > subdir/makefile
@echo "---MAKEFILE CONTENTS---"
@cd subdir && cat makefile
@echo "---END mAKEFILE CONTENTS---"
cd subdir && $(MAKE)
clean:
rm -rf subdir
5.7
You can make a list of commands like so:
define sweet
echo "hello"
echo "target:" $@
echo "prereqs:" $<
endef
.PHONY: all
all: one
$(sweet)
# Append @ here to append @ to all the commands in sweet: @$(sweet)
one:
touch one
clean:
rm -f one
6.1
Reference variables using ${} or $()
x = dude
.PHONY: all
all:
echo $(x)
echo ${x}
# Bad practice, but works
echo $x
6.2
Two flavors of variables:
recursive - only looks for the variables when the command is used, not when it’s defined.
simply expanded - like normal imperative programming – only those defined so far get expanded
# This will print "later" at the end
one = one ${later_variable}
# This will not
two := two ${later_variable}
later_variable = later
.PHONY: all
all:
echo $(one)
echo $(two)
6.2
Simply expanded allows you to append to a variable. Recursive definitions will give an infinite loop error.
one = hello
one := ${one} there
.PHONY: all
all:
echo $(one)
6.2
?= only sets variables if they have not yet been set
one = hello
one ?= will not be set
two ?= will be set
.PHONY: all
all:
echo $(one)
echo $(two)
6.2
Spaces at the end of a line are not stripped, ones at the start are
To make a variable with a single space, have a variable guard
with_spaces = hello # end of line
after = $(with_spaces)there
nullstring =
space = $(nullstring) # end of line
.PHONY: all
all:
echo "$(after)"
echo start"$(space)"end
6.3
You can text replace at the end of each space seperated word using $(var:a=b)
Note: don’t put spaces in between anything; it will be seen as a search or replacement term
Note: This is shorthand for using the “patsubst” expansion function
foo := a.o b.o c.o
bar := $(foo:.o=.c)
.PHONY: all
all:
echo $(bar)
6.3
You can use % as well to grab some text!
foo := a.o b.o c.o
bar := $(foo:%.o=%)
.PHONY: all
all:
echo $(bar)
6.5
An undefined variable is actually an empty string :o
.PHONY: all
all:
echo $(nowhere)
6.6
Use += to append
foo := start
foo += more
.PHONY: all
all:
echo $(foo)
6.7
You can override variables that come from the command line by using “override”.
Here we ran make with make some_option=hi
override some_option += additional
.PHONY: all
all:
echo $(some_option)
6.8
“define” is actually just a multiline variable defintion. It has nothing with being a function.
Note here that it’s a bit different than having a semi-colon between commands, because each is run
in a seperate shell, as expected.
one = export blah="I was set!"; echo $$blah
define two
export blah=set
echo $$blah
endef
.PHONY: all
all:
@echo "This prints I was set:"
@$(one)
@echo "This does not:"
@$(two)
6.10
Variables can be assigned for specific targets
all: one = cool
.PHONY: all
all:
echo one is defined: $(one)
.PHONY: other
other:
echo one is nothing: $(one)
6.11
You can assign variables for specific target patterns
%.c: one = cool
blah.c:
echo one is defined: $(one)
.PHONY: other
other:
echo one is nothing: $(one)
7.1
Conditional/If statements
foo = ok
all:
ifeq ($(foo), ok)
echo "foo equals ok"
else
echo "nope"
endif
7.2
Check if variable is empty
nullstring =
foo = $(nullstring) # end of line; there is a space here
all:
ifeq ($(strip $(foo)),)
echo "foo is empty"
endif
ifeq ($(foo),)
echo "foo doesn't even have spaces?"
endif
7.2
ifdef does not expand variable references; it just sees if something is defined at all
bar =
foo = $(bar)
all:
ifdef foo
echo "foo is defined"
endif
ifdef bar
echo "but bar is not"
endif
7.3
Search for a MAKEFLAG
bar =
foo = $(bar)
all:
# Search for the "-i" flag. MAKEFLAGS is just a list of single characters, one per flag. So look for "i" in this case.
ifneq (,$(findstring i, $(MAKEFLAGS)))
echo "i was passed to MAKEFLAGS"
endif
8.1
Call functions with $(fn, arguments) or $(fn, arguments)
bar := $(subst not, totally, "I am not superman")
bar2 := $(subst not, totally, "I am not superman")
.PHONY: all
all:
@echo $(bar)
@echo $(bar2)
8.1
If you want to replace spaces or commas, use variables
comma := ,
empty:=
space := $(empty) $(empty)
foo := a b c
bar := $(subst $(space),$(comma),$(foo))
.PHONY: all
all:
@echo $(bar)
8.1
Do NOT include spaces in the arguments after the first. That will be seen as part of the string.
comma := ,
empty:=
space := $(empty) $(empty)
foo := a b c
bar := $(subst $(space), $(comma) , $(foo))
.PHONY: all
all:
# Output is ", a , b , c". Notice the spaces introduced
@echo $(bar)
8.2, 8.3, 8.9 TODO do something about the fns
TODO 8.7 origin fn? Better in documentation?
8.4
foreach takes:
$(foreach var,list,text) and sets var to each word in list, and outputs outputs that into a “list” of words in text. By list I mean a space seperated sentence of words.
This appends an exclamation after each word
foo := who are you
bar := $(foreach wrd,$(foo),$(wrd)!)
.PHONY: all
all:
@echo $(bar)
8.5
If: (in a function instead of normal.. call this the functional style)
Checks if the first argument is nonempty. If so runs the second argument, otherwise runs the third.
foo := $(if this-is-not-empty,then!,else!)
empty :=
bar := $(if $(empty),then!,else!)
.PHONY: all
all:
@echo $(foo)
@echo $(bar)
8.6
Call: $(call variable,param,param)
Sets each of the params as $(1), $(2), etc.
$(0) is set as the variable name
sweet_new_fn = Variable Name: $(0)$ First: $(1) Second: $(2) Empty Variable: $(3)
.PHONY: all
all:
@echo $(call sweet_new_fn, go, tigers)
8.8
shell - This calls the shell, but it removes newlines!
.PHONY: all
all:
@echo $(shell ls -la) # Very ugly because the newlines are gone!
9
--dry-run, --touch, --old-file
.make clean run test
runs the ‘clean’ goal, then ‘run’, and then ‘test’.