Als nächstes blicken wir nochmal zurück auf Make und schauen, wie wir unsere Makefiles

noch dahingehend erweitern können, dass sie kürzer und prägnanter werden.

Dazu schauen wir uns einige der Makros an, die Make zur Verfügung stellt.

Hier sind einige, die recht praktisch sind und die ihr in euren Makefiles einbauen solltet.

Das erste Makro ist $add. $add evaluiert jeweils zu dem Namen des Targets, in dem das Makro

eingebaut ist. In dem Beispiel haben wir eine Regel, die das Target test baut. Vom Namen

des Targets sind durch einen Doppelpunkt die Abhängigkeiten getrennt. In dem Fall ist

die Abhängigkeit test.c. In der Zeile darunter befindet sich der Befehl, der ausgeführt

wird, wenn das Target gebaut werden soll. Und in dem Befehl kann das Makro $add verwendet

werden. Da es zu dem Namen des Targets evaluiert, wird es hier verwendet, um dem GCC den Namen

der Ausgabe-Datei mitzuteilen, indem es als Argument an die Option binstrich o gesetzt

wird.

Das zweite Makro ist $, gefolgt von einem kleiner Zeichen. Dieses Makro evaluiert zu

der ersten Abhängigkeit, die beschrieben steht. In diesem Beispiel haben wir das Target test.o

mit den Abhängigkeiten test.c und test.h. Wenn wir nun also das Makro $, dann evaluiert

dieses zu der ersten Abhängigkeit, in diesem Fall test.c.

Und das dritte Makro ist $, bzw. $, gefolgt von dem kleinen Dächlein. Dieses Makro expandiert

zu allen Abhängigkeiten, die genannt werden. Das heißt im folgenden Beispiel, indem das

Target test gebaut wird, abhängig von den Dateien test.o und func.o, evaluiert das Makro

zu den Strings test.o und func.o. Es werden also alle Abhängigkeiten mit in den Befehl

übernommen.

So alleine nehmen wir die gerade genannten Makros nur ein kleines bisschen Schreibarbeit

ab. Interessant wird es, wenn wir die Makros nun mit den Musterregeln bzw. den Patternregeln

kombinieren. Mit einer Patternregel können wir einen Platzhalter für einen Namen gefolgt

von einem Prä oder Suffix einfügen. Das Muster im Namen des Targets wird dann auf die Abhängigkeiten

übertragen.

Am besten lässt sich dies am Beispiel erklären. Wir haben hier eine Regel, die das Target

%.o beschreibt. Dabei bezeichnet das % hier den Platzhalter für das Muster.

In der Abhängigkeit beziehen wir uns auf eine Datei %.c. Was nun bei der Ausführung

des Makefiles geschieht, ist, dass Make prüft, ob eine Datei mit dem Suffix.o gebaut werden

soll. Falls dies der Fall ist, dann trifft diese Regel zu. Soll zum Beispiel eine Datei

test.o gebaut werden, wird erkannt, dass das Target das Suffix.o beinhaltet und die Patternregel

greift.

Hier wird nun das Muster auf den Namen des Targets test.o angewandt und es wird zu test.

Abhängig davon wird die Abhängigkeit abgeleitet. Das heißt %.c wird zu test.c.

Wenn anschließend der Befehl ausgeführt wird, können die zuvor genannten Makros verwendet

werden. In unserem Beispiel wird das Makro $, expandiert zu der ersten Abhängigkeit.

Die erste Abhängigkeit ist hier wieder die Patternregel %.c, was im konkreten Fall zu

einem Test.c wird.

Ergänzend zu den Patternregeln kann man auch Regeln ohne Kommando beschreiben. Diese

bestehen dann nur aus dem Target und den Abhängigkeiten jeweils durch einen Doppelpunkt getrennt.

Damit können die Abhängigkeiten der Patternregeln überschrieben und damit konkretisiert werden.

In diesem Beispiel definieren wir uns eine Abhängigkeit für das Target test.o und sagen,

dass dies abhängt von den Dateien test.c, test.h und func.h.

Wenn wir nun die beiden Beispiele in einem Makewell kombinieren und test.o bauen wollen,

begreifen die Abhängigkeiten auf die Datei test.c, test.h und func.h, aber der Befehl

zur Erzeugung des Targets wird von der Patternregel abgeleitet.

Möchte man eine Patternregel überschreiben, dann kann man dies machen, indem man eine

konkrete Regel, bestehend aus dem Target, den Abhängigkeiten und dem Kommando, spezifiziert.