21.8 make 
Nun kommen wir zu einem der wichtigsten und nützlichsten Tools, die einem bei der Entwicklung von Software unter Unix-Betriebssystemen zur Verfügung stehen. Dieses Tool trägt den Namen make und kümmert sich, sofern man das möchte, um den Übersetzungsvorgang eines gesamten Softwareprojekts.
Gesetzt den Fall, dass es ein beliebiges Softwareprojekt mit drei C-Quelldateien gäbe, müsste man, um diese nun zu übersetzen und zu linken, beispielsweise folgende Aufrufe durchführen:
$ gcc -Wall -c file1.c $ gcc -Wall -c file2.c $ gcc -O2 -o prog file1.o file2.o $ gcc -Wall -c file3.c $ gcc -O -o prog2 file3.o
Listing 21.35 Übersetzen des imaginären Projekts
Diese Befehle bei jeder Übersetzung erneut einzugeben ist ein großer Aufwand, der einem schnell die Lust an der Entwicklung verderben könnte. Nun werden Sie eventuell vorschlagen, doch ein simples Shellskript zu schreiben, das diese Befehle ausführt. Ja, das wäre zumindest eine komfortablere Alternative. make jedoch kann Ihnen da weitaus mehr bieten.
21.8.1 Makefile 
Um make zu verwenden, wird zunächst im Hauptverzeichnis des Softwareprojekts eine Datei mit dem Namen Makefile erstellt. In diese Datei werden die Anweisungen eingetragen, die zur Übersetzung notwendig sind. Ruft man dann in diesem Verzeichnis make auf, so führt es die Anweisungen in dem Makefile aus und übersetzt das Programm. So viel zur grundlegenden Funktionalität von make. Bis hierhin bietet make jedoch noch keinen Vorteil gegenüber einem Shellskript.
Targets und Dependencies
Ein Makefile besteht aus sogenannten Targets und Dependencies. Ein Target, also ein Übersetzungsziel, hat dabei gewisse Dependencies, also Abhängigkeiten, die vorhanden bzw. erfüllt sein müssen, damit die Übersetzung des Targets durchgeführt werden kann. Ist eine Abhängigkeit nicht erfüllt, versucht make zuerst, diese Abhängigkeit zu erfüllen. Standardmäßig wird dabei die folgende Schreibweise verwendet:
target : dependency1 ... dependencyN
Um dies zu verstehen, benötigt man ein kleines Praxisbeispiel. Im Folgenden sehen Sie ein mögliches Makefile für den obigen Übersetzungsvorgang:
all : file1.o file2.o file3.o
gcc -O2 -o prog file1.o file2.o
gcc -O -o prog2 file3.o
file1.o : file1.c
gcc -Wall -c file1.c
file2.o : file2.c
gcc -Wall -c file2.c
file3.o : file3.c
gcc -Wall -c file3.cListing 21.36 Makefile
Zunächst haben wir das Taget »all« spezifiziert. Dieser Name ist frei gewählt und kann auch anders lauten. Dort werden die beiden Programme gelinkt. Damit diese Programme jedoch gelinkt werden können, müssen die entsprechenden Objektdateien erstellt werden. Da diese in den Targets file1.o, file2.o und file3.o erstellt werden, werden von make also erst die entsprechenden Übersetzungsvorgänge durchgeführt. Damit make dies wiederum tun kann, werden im Falle von file1.o die Datei file1.c und im Falle von file2.o die Datei file2.c benötigt, weshalb wir diese als Abhängigkeiten der Targets angegeben haben.
Die Übersetzungsanweisungen für ein Target müssen unter die Zeile der Target-Angabe geschrieben werden und mit einem Tab eingerückt werden.
So weit, so gut. Führt man make nun aus, kann man sehen, was dabei für Schritte unternommen werden:
$ make gcc -Wall -c file1.c gcc -Wall -c file2.c gcc -Wall -c file3.c gcc -O2 -o prog file1.o file2.o gcc -O -o prog2 file3.o
Listing 21.37 make aufrufen
Führt man nun, ohne etwas an den Quellcodes zu verändern, make erneut aus, kommt der Zaubertrick zum Vorschein:
$ make gcc -O2 -o prog file1.o file2.o gcc -O -o prog2 file3.o
Listing 21.38 make ist schlau.
Da sich nichts an den Abhängigkeiten der Targets file1.o bis file3.o geändert hat, müssen diese nicht neu übersetzt werden.
make kann also davon ausgehen, dass die entsprechenden Objektdateien weiterhin verwendet werden können, und muss das Programm nur linken.
Verändert man nun etwas in einer der Dateien, beispielsweise in der Datei file3.c, wird make nur die zugehörige Objektdatei neu übersetzen und den Link-Vorgang erneut durchführen. Bei großen Projekten kann dies die Übersetzungszeit unter Umständen um viele Minuten und im Extremfall sogar um Stunden verkürzen.
Zu sagen ist noch, dass make die Veränderungen von Quelldateien anhand von deren Timestamps überprüft. Diese können, wie Sie bereits wissen, mit dem Programm touch verändert werden. Eine Veränderung an der Datei file3.c kann also dadurch simuliert werden, dass man sie toucht.
$ touch file3.c $ make gcc -Wall -c file3.c gcc -O2 -o prog file1.o file2.o gcc -O -o prog2 file3.o
Listing 21.39 Veränderungen an einer Quelldatei durchführen
Die Sache mit dem !
Hinter einem Target muss nicht unbedingt ein Doppelpunkt stehen. Dieser sagt nämlich aus, dass das Target von diesen Dependencies abhängt und nur dann übersetzt wird, wenn sich diese Abhängigkeiten ändern.
!
Was aber tut man, wenn man möchte, dass ein Taget immer übersetzt wird? Dazu kann man, sofern die BSD-Extensions unterstützt werden, den Operator »!« verwenden. Um beispielsweise die Objektdatei file3.o bei jeder Übersetzung zu erzeugen, müsste man die folgende Modifizierung durchführen:
file3.o ! file3.c
gcc -Wall -c file3.cListing 21.40 !
Suffixregeln
make kann mit sogenannten Suffixen arbeiten. Dabei wird angegeben, welche Schritte zur Übersetzung eines Dateityps in einen anderen notwendig sind. Dies kann beispielsweise die Übersetzung einer .c-Datei in eine .o-Datei, also eine Objektdatei, sein.
In unserem bisherigen Makefile mussten wir für jeden Compileraufruf die entsprechenden Parameter etc. übergeben. Nun kann man sich dank Suffixregeln diese Arbeit sparen. Dazu definiert man zunächst die allgemeine Suffixregel in der folgenden Form:
.<Ausgangsdatei-Endung>.<Zieldatei-Endung>: Anweisung1 Anweisung2 ... AnweisungN
Listing 21.41 Aufbau einer Suffix-Regel
Für die Übersetzung unserer C-Dateien in Objektdateien wäre beispielsweise folgende Suffixregel angebracht:
.c.o: gcc -c -Wall $<
Listing 21.42 .c.o
Dabei ist $< eine make-interne Variable, die für die aktuelle Quelldatei steht.
Nachdem nun diese Suffixregel erstellt wurde, können wir das Makefile viel kompakter gestalten und müssen für die Übersetzung von .c- in .o-Dateien nur noch Target und Ziel angeben. Das neue Makefile würde dann so aussehen:
.c.o : gcc -c -Wall $< all : file1.o file2.o file3.o gcc -O2 -o prog file1.o file2.o gcc -O -o prog2 file3.o file1.o : file1.c file2.o : file2.c file3.o : file3.c
Listing 21.43 Makefile mit Suffixregel
21.8.2 Makefile-Makros
Innerhalb eines Makefile können sogenannte Makros erstellt werden. Diese haben grundlegend erst einmal die Funktionalität einer Variablen in der Shell. Einem Makro wird ein Wert zugewiesen, und dieser kann später, etwa bei der Übersetzung, über den Makronamen verwendet werden. Die Zuweisung eines Wertes erfolgt wie in der Shell mit dem Gleichheitsoperator (=).
Man verwendet Makros besonders häufig bei Compiler-Optionen. So könnten wir für unser Makefile beispielsweise das Makro CFLAGS definieren:
CFLAGS=-c -Wall
Listing 21.44 CFLAGS
Angesprochen werden Variablen in der Form $(NAME), also etwa als $(CFLAGS).
Möchte man nun aber hin und wieder eine Debugging-Option hinzufügen, aber darauf auch hin und wieder verzichten, kann man beispielsweise jedes Mal die Compiler-Option -DDEBUG oder -g hinzufügen. Leichter wäre es allerdings, immer eine Zeile für diese Einstellung zu verwenden, die diese Option zu den restlichen Compiler-Optionen hinzufügt, wenn sie nicht auskommentiert ist. Um einen Wert auf solch eine Weise an ein Makro anzuhängen, verwendet man den Operator +=:
CFLAGS+=-DDEBUG #CFLAGS+=-g
Listing 21.45 +=
21.8.3 Shell-Variablen in Makefiles
Nicht nur Makros können angesprochen werden: Auch auf Shell-Variablen können Sie zugreifen. Dafür lautet die Syntax jedoch nicht $(NAME), sondern $(NAME)$. Beachten Sie, dass diese Variablen von der Shell exportiert sein müssen.
21.8.4 Einzelne Targets übersetzen
Zudem ist es möglich, einzelne Targets gezielt zu übersetzen. Dafür muss man make nur den Namen des jeweiligen Targets bzw. die Namen der jeweiligen Targets übergeben. Auch hierbei werden automatisch die entsprechenden Abhängigkeiten übersetzt.
$ make file2.o
Listing 21.46 Das Target file2.o übersetzen
21.8.5 Spezielle Targets
Für make gibt es üblicherweise einige spezielle Targets, die fast jeder Entwickler in sein Makefile aufnimmt. Dazu zählen das Target clean und das Target install.
clean
Das clean-Target wird dazu benutzt, um die erzeugten Dateien nach einem Kompiliervorgang wieder zu löschen. Dies schafft saubere Entwicklungsverzeichnisse und Plattenplatz. Ein clean-Target könnte beispielsweise so aufgebaut sein:
clean : rm -f *.o rm -f prog prog2 rm -f *.core
Listing 21.47 clean-Target
install
Das install-Target hingegen wird üblicherweise zur automatischen Installation des Programms und seiner (Konfigurations-)Dateien im Dateisystem verwendet. Ein typisches install-Target sieht etwa so aus wie das folgende, das dem Xyria:DNSd-Server entnommen und für dieses Buch etwas vereinfacht und auf das Wichtigste gekürzt wurde:
install :
if [ ! -d /etc/xyria ]; then \
mkdir /etc/xyria; chmod 0755 /etc/xyria; fi
if [ ! -d /etc/xyria/zones ]; then \
mkdir /etc/xyria/zones; \
chmod 0755 /etc/xyria/zones; fi
cp dnsd.conf /etc/xyria/; chmod 0644 /etc/xyria/*
cp dnsd xydnsdbcreate /usr/local/sbin/Listing 21.48 install-Target
21.8.6 Tipps im Umgang mit make
Zum Schluss dieses Abschnitts seien noch ein paar Dinge angemerkt, die im Umgang mit make wissenswert sind.
@
Normalerweise gibt make alle Befehle aus, die für ein Target ausgeführt werden. Setzt man vor einen Befehl jedoch das @-Zeichen, wird dieser Befehl zwar ausgeführt, aber nicht selbst ausgegeben. Dies heißt jedoch nicht, dass die Ausgabe eines Befehls unterdrückt werden würde. Dies lässt sich, wie Sie bereits wissen, mit >/dev/null bewerkstelligen.
-f
Bei einigen Softwareprojekten heißen die Dateien, die Make verwenden soll, nicht Makefile, sondern beispielsweise Makefile.bsd-wrapper oder Makefile.bsd. Da make im Normalfall nur nach der Datei Makefile sucht, müssen Dateien, die anders heißen, über den Parameter -f angegeben werden.
make -f Makefile.bsd
include
Zudem ist es oftmals (besonders bei großen Projekten mit Subprojekten) sehr hilfreich, wenn Makefiles ineinander eingebunden werden können. Projekte wie das Betriebssystem »OpenBSD« haben dafür in jedem Quellverzeichnis nur ein minimales Makefile, das ein globaleres Makefile einbindet, in dem dann beispielsweise die Suffix-Regeln festgelegt sind.
include ../Makefile.inc
Listing 21.49 Einbinden eines Makefiles
