The badass tutorial for creating makefiles!

Tutorial 5: pattern matching and functions

Now its time to go into the useful stuff. This tutorial requires more files in order to understand how it works.

That means we need to change some things...

your folder name

makefile

prog.c

foo.c

First we start with the c-files:

prog.c

/* Simple C-program */
#include <stdio.h>

//Header to the function from foo.c
int foo(int,int);

int main()
{
	printf("3+2=%d\n",foo(3,2));
	
	return 0;
}

foo.c

int foo(int a,int b)
{
	return a+b;
}

Change the contents of the makefile to this:

#Another simple makefile.

CC = gcc
PROGRAM = prog

SRCS = $(wildcard ./*.c)

#simplified version of: $(patsubst %.c,%.o,$(SRCS))
OBJS = $(SRCS:%.c=%.o)

all: $(PROGRAM)

$(PROGRAM): $(OBJS)
	$(CC) $^ -o $@

%.o: %.c
	$(CC) $< -c -o $@

run: all
	./$(PROGRAM)
	
clean:
	rm $(OBJS)
	
%.print:
	echo $*

As with $@ and $<, $^ and $* works similarly

• $^ will get all the dependencies.
• $* will get whatever is found in %.

To test $* I made a test just for that. Try to run for example:

make hello_im_testing_this.print

It should return:

echo hello_im_testing_this
hello_im_testing_this

Before we get into how %.o: %.c is working we need to check the line with: SRCS = $(wildcard ./*.c). $(something var1,var2) is a built-in function, and the wildcard function communicates with the outside world and tries to find all files matching a certain pattern. In this case it searches for files in this directory ending with .c. This means that it should find prog.c and foo.c. As with bashscript it will return the value in a array, or:

prog.c foo.c

The next value will use another common makefile function: patsubst, but this is the lazy version. This line will change all .c files in the array to .o. Now we have a fresh variable $(OBJS) with:

prog.o foo.o

Time to run it

So when we run make run it should be executed in this order:

• all will go to $(PROGRAM)
• $(PROGRAM) waits for $(OBJS) to be executed, but this time $(OBJS) is an array prog.o foo.o so it will first try to find a target for prog.o and then foo.o
• As you probably can see above, there is no clear target for prog.o, so it will go through the % - targets. The target %.o will search for anything that ends with .o. As our target ends with .o - "its a match ❤". However there is a %.c dependancy. The % will get the stuff thats not the constants around %, like this (prog [%] | .o [.o]) so the dependancy becomes ([%] prog | .c) → prog.c. There is no target for prog.c so it will just listen if prog.c was changed. After prog.o it will do the same thing for foo.o
• The rest is pretty much the same from the previous tutorials. One main difference is that we use $^, which will get prog.o foo.o

Instead of %.o:%.c its common to write .c.o:, which does pretty much the same. However i recommend to use %.o:%.c because its usable for other languages, which u may not know about, such as %.html:%.php for example (even if its possible to make your own .php.html:,although more complicated to do).

See also:

• Pattern-Match