12.3    Make

Eines der wichtigsten und nützlichsten Tools, die Ihnen bei der Entwicklung von Software unter Unix-Betriebssystemen zur Verfügung stehen, trägt den Namen Make und kümmert sich, sofern Sie das möchten, um den Übersetzungsvorgang eines gesamten Softwareprojekts.

Um ein beliebiges Softwareprojekt mit drei C-Quelldateien zu übersetzen und zu linken, müssten Sie 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 12.18     Ü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.

12.3.1    Makefile

Um Make zu verwenden, erstellen Sie zunächst im Hauptverzeichnis des Softwareprojekts eine Datei mit dem Namen Makefile. In ihr tragen Sie die Anweisungen ein, die zur Übersetzung notwendig sind. Rufen Sie dann in diesem Verzeichnis make auf, so führt es die Anweisungen im Makefile aus und übersetzt das Programm. So viel zur grundlegenden Funktionalität von Make. Bis hierhin bietet es 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 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

Ein kleines Praxisbeispiel soll diese Schreibweise verständlich machen. 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.c

Listing 12.19     Makefile

Zunächst haben wir das Target all spezifiziert. Dieser Name ist frei gewählt und kann auch anders lauten. Dort werden die beiden Programme gelinkt. Damit dies jedoch geschehen kann, müssen die entsprechenden Objektdateien erstellt werden. Da diese in den Targets file1.o, file2.o und file3.o erstellt werden, führt Make also erst die entsprechenden Übersetzungsvorgänge durch. Damit es dies wiederum tun kann, wird im Fall von file1.o die Datei file1.c und im Fall 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 direkt unter die Zeile der Target-Angabe geschrieben und mit einem Tab eingerückt werden. Manche Texteditoren ersetzen Tabs durch Leerzeichen, was allerdings nicht mit Make funktioniert. In solchen Fällen helfen ein paar Klicks zum Ändern der Konfiguration des jeweiligen Editors.

So weit, so gut. Führen Sie make nun aus, sehen Sie, welche 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 12.20     make aufrufen

Führen Sie 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 12.21     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, so wird Make nur die zugehörige Objektdatei neu übersetzen und den Link-Vorgang erneut durchführen. Bei großen Projekten kann dies die Übersetzungszeit um viele Minuten, manchmal sogar um Stunden, verkürzen.

Anzumerken 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 12.22     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 den dahinter angegebenen Abhängigkeiten (»Dependencies«) abhängt und nur dann neu übersetzt wird, wenn sich diese Abhängigkeiten ändern.

Wie aber erreicht man, dass ein Target 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 Änderung durchführen:

file3.o ! file3.c
    gcc -Wall -c file3.c

Listing 12.23     !

Suffixregeln

Make kann mit sogenannten Suffixregeln arbeiten. Dabei wird angegeben, welche Schritte zur Übersetzung eines Dateityps in einen anderen notwendig sind – beispielsweise bei der Übersetzung einer .c-Datei in eine .o-Datei, also eine Objektdatei.

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 12.24     Aufbau einer Suffixregel

Für die Übersetzung unserer C-Dateien in Objektdateien wäre beispielsweise folgende Suffixregel angebracht:

.c.o:
   gcc -c -Wall $<

Listing 12.25     Die Suffixregel .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 das Target und Ziel angeben. Das neue Makefile sähe dann so aus:

.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 12.26     Makefile mit Suffixregel

12.3.2    Makros

Innerhalb eines Makefiles 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 Werts erfolgt wie in der Shell mit dem Gleichheitsoperator (=).

Man verwendet Makros besonders häufig bei Compileroptionen. So könnten wir für unser Makefile beispielsweise das Makro CFLAGS definieren:

CFLAGS=-c -Wall

Listing 12.27     CFLAGS

Angesprochen werden Makros in der Form $(NAME), also etwa als $(CFLAGS).

Möchten Sie nun manchmal eine Debugging-Option hinzufügen, aber darauf auch manchmal verzichten, so können Sie beispielsweise jedes Mal die Compileroption -DDEBUG oder -g hinzufügen. Leichter noch ist es, immer eine Zeile für diese Einstellung zu verwenden, die diese Option zu den restlichen Compileroptionen hinzufügt, wenn sie nicht auskommentiert ist. Um auf diese Weise einen Wert an ein Makro anzuhängen, verwenden Sie den Operator +=:

CFLAGS+=-DDEBUG
#CFLAGS+=-g

Listing 12.28     Verwendung des Operators +=

12.3.3    Shellvariablen in Makefiles

Nicht nur Makros können angesprochen werden: Auch auf Shellvariablen können Sie zugreifen. Die entsprechende Syntax lautet jedoch nicht $(NAME), sondern $(NAME)$. Beachten Sie, dass diese Variablen von der Shell exportiert sein müssen.

12.3.4    Einzelne Targets übersetzen

Sie können auch einzelne Targets gezielt übersetzen. Übergeben Sie hierzu make nur den Namen des jeweiligen Targets bzw. die Namen der jeweiligen Targets. Auch hierbei werden automatisch die entsprechenden Abhängigkeiten übersetzt.

$ make file2.o

Listing 12.29     Das Target file2.o übersetzen

12.3.5    Spezielle Targets

Für Make gibt es üblicherweise einige spezielle Targets, die fast alle Entwicklerinnen und Entwickler in ihr Makefile aufnehmen. Dazu zählen clean und install.

Mit dem clean-Target werden die erzeugten Dateien nach einem Kompiliervorgang wieder gelöscht. 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 12.30     clean-Target

Das install-Target hingegen wird üblicherweise zur automatischen Installation des Programms und seiner (Konfigurations-)Dateien im Dateisystem verwendet. Ein typisches install-Target sieht etwa wie das folgende aus, das dem Xyria:DNSd-Server entnommen und für dieses Buch etwas vereinfacht 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 12.31     install-Target

12.3.6    Tipps im Umgang mit Make

Zum Schluss dieses Abschnitts möchten wir Sie noch auf einige wissenswerte Aspekte im Umgang mit Make hinweisen.

Normalerweise gibt make alle Befehle aus, die für ein Target ausgeführt werden. Setzen Sie vor einen Befehl jedoch das @-Zeichen, wird dieser Befehl zwar ausgeführt, aber nicht selbst ausgegeben. Dies heißt jedoch nicht, dass seine Ausgabe unterdrückt wird. Dies lässt sich, wie Sie bereits wissen, mit >/dev/null bewerkstelligen.

Bei einigen Softwareprojekten heißen die Dateien, die Make verwenden soll, nicht Makefile, sondern etwa Makefile.bsd-wrapper oder Makefile.*bsd. Da Make im Normalfall nur nach der Datei Makefile sucht, müssen anderslautende Dateinamen über den Parameter -f angegeben werden:

make -f Makefile.bsd

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 Suffixregeln festgelegt sind.

include ../Makefile.inc

Listing 12.32     Einbinden eines Makefiles