Eine kleine Makefile Einführung

Transkript

1 Eine kleine Makefile Einführung Was ist ein Makefile? Ein Makefile ist eine Art Steuerungsdatei für das Programm make. Dabei handelt es sich um eine Textdatei, die in menschenlesbarer Form Regeln enthält, nach denen make bestimmte s ausführt. Sie kann z.b. dafür verwandt werden, Programme zu kompilieren oder tar-archive zu erstellen. Die Stärke von make liegt dabei darin, das man im Makefile sogenannte Abhängigkeiten definieren kann. Diese sorgen dafür, das make nach seinem Aufruf z.b. nur Dateien compiliert, wenn diese sich geändert haben (dazu später mehr). Dies kann nützlich sein wenn man große Projekte hat, die aus vielen Dateien bestehen, von denen sich aber bei einer erneuten Compilation nicht alle Dateien geändert haben müssen (stellt euch mal vor, die Entwickler von Netscape z.b. würden nach Änderung einer Zeile in einer Datei ihr komplettes Projekt neu übersetzten...). Wie sieht ein Makefile aus? Ein Makefile ist eine Textdatei, die eine oder mehrere Regeln enthält. Die grobe Struktur ist dabei Folgende: Ziel1: Abhängigkeit(en) usw. Ziel2: Abhängigkeit(en) usf. Ziel : Ziel bezeichnet meist das Programm welches man übersetzten möchte (z.b. aufgabe18). Es kann aber auch für eine Aktion stehen (z.b. für das erstellen eines tar- Archives. Dann könnte hier z.b. tar stehen). Abhängigkeiten : Hier stehen die Namen der Dateien, von denen das Ziel abhängt. D.h. wenn wir z.b. ein Programm aufgabe18.c übersetzten wollen, dann ist die einzige 1

2 Eine kleine Makefile Einführung 14. Dezember Datei, in der sich etwas ändern kann aufgabe18.c. Entsprechend würde diese hier stehen. Weshalb, wird weiter unten erklärt. : Hier steht das welches ausgeführt wird, sofern die Abhängigkeiten erfüllt sind. Dabei ist zu beachten, das jedes dieser s durch einen Tabulator eingerückt werden muss. Es dürfen keine Leerzeichen verwendet werden! Auch dürfen innerhalb eines s keine Zeilenumbrüche vorkommen. Ein könnte z.b. der Aufruf des s tar sein, sofern man hier ein tar-archiv erstellen möchte. Was macht make jetzt damit? Wenn man nun den Befehl make in der Eingabeaufforderung mit dem auszuführenden Ziel aufruft galadriel{usr} make Ziel1 dann sucht make innerhalb des Verzeichnisses nach einem Makefile mit dem Namen makefile oder Makefile. Hat es eines gefunden, sucht make innerhalb von diesem das Ziel Ziel1 und prüft die Abhängigkeiten. D.h., make prüft nun, ob sich eine der Dateien, die an der Stelle Abhängigkeiten aufgelistet sind, geändert hat. Wenn nicht, beendet make sich mit der Nachricht: make: Ziel1 is up to date. Hat sich allerdings eine Datei seid dem letzten Aufruf von make geändert, so führt make die unter angegebenen s aus. Gibt man statt make Ziel1 einfach nur make ein, so sucht make nach einem entsprechenden Makefile und führt einfach die erste Regel aus, die in dem Makefile steht. Beispiele 1. Beispiel Nehmen wir an, wir haben in einem Verzeichnis ein C-Programm mit dem Namen aufgabe18.c. Dieses wollen wir nun mit Hilfe eines Makefiles übersetzen. Dazu möchten wir gerne den sogenannten GNU C-Compiler - kurz gcc - verwenden. Außerdem möchten wir, das unsere ausführbare Datei aufgabe18 und nicht a.out heißt. Dann könnte ein mögliches Makefile wie folgt aussehen: aufgabe18: aufgabe18.c gcc -o aufgabe18 aufgabe18.c

3 Eine kleine Makefile Einführung 14. Dezember Um dieses nun auszuführen muss man entweder make oder make aufgabe18 in der Eingabeaufforderung eingeben. make sucht dann in dem Makefile das Ziel aufgabe18. An der Stelle steht, das dieses Ziel von der Datei aufgabe18.c abhängt. make prüft nun also, ob sich die Datei aufgabe18.c, welche sich im selben Verzeichnis befindet, geändert hat, seid make das letzte Mal aufgerufen wurde (dies prüft make anhand eines Zeitstempels). Hat sich diese Datei geändert, so ruft make das angegebene auf, also den Befehl gcc -o aufgabe18 aufgabe18.c. 2. Beispiel Wie schon erwähnt, kann man mit make noch wesentlich mehr machen als Programme zu übersetzten. Man kann z.b. tar-archive erstellen. Dazu gibt es verschiedene Möglichkeiten. Nehmen wir an, wir arbeiten mit dem Login tad. Dann befindet sich unser Homeverzeichnis unter \home\tad. Nehmen wir weiter an, wir haben ein Arbeitsverzeichnis mit Namen Nebenfach und dann noch eines mit dem Namen Programme, in dem wir unsere Programmieraufgaben erledigen (der vollständige Pfad bis hier wäre nun also \home\tad\nebenfach\programme). Die Abgaberegeln besagen, dass das tar-archiv eine Verzeichnisstruktur der Form xxx_yyy/aufgabenr bieten soll, in dem sich die entsprechenden abzugebenden Dateien befinden. Nehmen wir an, wir arbeiten mit jemandem zusammen der das Login yat hat. Weiter wollen wir die Aufgabe mit der Nr 18 abgeben. Damit wir nach dem Programmieren die Dateien nicht noch weiter umsortieren müssen, möchten wir gleich in der geforderten Verzeichnisstruktur arbeiten. Also sieht unser Gesamtpfad bis hin zur Aufgabe 18 wie folgt aus: \home\tad\nebenfach\programme\tad_yat\aufgabe18 Normalerweise rufen wir jetzt von dem Unterverzeichnis Programme aus den Befehl tar -xf tad_yat_aufgabe18.tar tad_yat\aufgabe18\* auf. Um aber nicht jedesmal diesen langen Befehl eingeben zu müssen, können wir uns an die Stelle \home\tad\nebenfach\programme auch ein Makefile legen und dieses dann von diesem Verzeichnis aus aufrufen, um das entsprechende tar-archiv zu erzeugen. Dies möchten wir gerne durch den Aufruf des Befehls make tar tun. Dann könnte unser Makefile wie folgt aussehen: tar: tad_yat/aufgabe18/*.c tad_yat/aufgabe18/*.h tad_yat/aufgabe18/makefile tar -cf tad_yat_aufgabe18.tar tad_yat/aufgabe18/* Das Ziel ist also die Regel mit Namen tar, die Abhängigkeiten sind die.c und ggf..h Dateien und das abzugebende Makefile in dem Unterverzeichnis tad_yat/aufgabe18. So funktioniert das Makefile. Allerdings ist es etwas umständlich, dieses auf die jeweilige Situation anzupassen. So muss man z.b. immer die Aufgabennummer an hier 5 Stellen ändern. Auch muss man, wenn sich die Abhängigkeiten ändern (wenn man z.b. in Aufgabe 19 keine.h Dateien mehr hat), relativ viel löschen, bzw. hinzufügen. Um sich auch diese Dinge ein wenig zu vereinfachen, kann man sich in einem Makefile Variablen definieren.

4 Eine kleine Makefile Einführung 14. Dezember Diese Variablen sind in erster Linie Variablen, denen man einen Text zuordnen kann. An jeder Stelle, an der diese Variable dann wieder auftaucht, wird diese während der Ausführung durch den entsprechenden Text ersetzt. Man kann sich diesen Mechanismus ähnlich dem der EBNF vorstellen, in denen Non-Terminalsymbole entsprechend ersetzt werden. Definiert wird ein Variable durch Variablenname = Text, wobei Variablenname eben der Name der Variablen ist und Text der zugewiesene Text, der dann eingesetzt wird. Aufgerufen wird die Variable an entsprechender Stelle dann durch $(Variablenname). Dabei dient das Dollarzeichen dazu make zu signalisieren, das nun eine Variable folgt. Damit make auch weiß, wo eine Variable beginnt und endet, wird diese in Klammern eingefasst. Mit diesem Mechanismus könnte das oben angegebene Beispiel wie folgt aussehen: DEPENDENCY = $(DIR)/Makefile $(DIR)/*.c $(DIR)/*.h tar: $(DEPENDENCY_DIR) tar -cf $(GROUP)_Aufgabe$(EXERCISE).tar $(DIR)/* Hierbei stellen EXERCISE, GROUP, DIR und DEPENDENCY Variablen dar, die durch den rechts stehenden Teil ersetzt werden. Wie zu erkennen ist, kann man sich seine Variablen dabei auch rekursiv definieren. Wie zu erkennen ist, braucht man nun nurnoch die bei EXERCISE stehende Nummer zu ersetzen, um für eine andere Aufgabe ein tar-archiv zu erstellen. Ebenso müssen bei sich ändernden Abhängigkeiten nur der hinter der Variable DEPENDENCY stehende Teil angepasst werden. 3. Beispiel Mit Hilfe der Variablen lassen sich auch komplexere Makefiles einigermaßen übersichtlich halten. Es wäre natürlich praktisch, wenn ich - unabhängig von meiner eigenen Verzeichnisstruktur - eine Möglichkeit hätte, ein korrektes tar-archiv mit möglichst wenig Aufwand zu erstellen. Dazu würde man vielleicht gerne direkt in dem Verzeichnis, in dem man auch programmiert, ein Makefile verwenden, welches eigenständig für die richtige Verzeichnisstruktur sorgt, die benötigten Dateien in diese Verzeichnisstruktur kopiert, das tar-archiv erstellt und anschließend wieder aufräumt. Diese Funktionalität liefert folgendes Makefile: DEPENDENCY = Makefile *.c *.h

5 Eine kleine Makefile Einführung 14. Dezember tar: $(DEPENDENCY) mkdir $(GROUP) && mkdir $(GROUP)/Aufgabe$(EXERCISE) && cp *.c *.h Makefile $(DIR)/ && tar -cf $(GROUP)_Aufgabe$(EXERCISE).tar $(DIR)/* && rm $(DIR)/* && rmdir $(GROUP)/Aufgabe$(EXERCISE) && rmdir $(GROUP) Dieses Makefile erstellt zuerst ein Unterverzeichnis mit dem Namen tad_yat, in diesem eines mit dem Namen Aufgabe18, kopiert anschließend alle Dateien mit der Endung.c, mit der Endung.h und die Datei mit dem Namen Makefile in das erstellte Verzeichnis. Als nächstes erstellt make das tar-archiv, löscht die Dateien wieder, löscht nun das Verzeichnis Aufgabe18 und als Letztes das Verzeichnis mit dem Namen tad_yat. Wie zu erkennen, muss dieses Makefile in dem Verzeichnis liegen, in dem auch schon die Programmdateien selber liegen, also nach unser Verzeichnisstruktur unter \home\tad\nebenfach\programme\tad_yat\aufgabe18 In diesem liegt allerdings schon das Makefile, mit dem wir unser Programm übersetzten. Da aber, wie Eingang erwähnt, ein Makefile mehrere Ziele enthalten kann, lassen sich diese beiden Ziele in einem Makefile zusammenfassen (und unter Verwendung der Variablen auch die Regel zum Übersetzen vereinfachen): DEPENDENCY = Makefile *.c *.h DEPENDENCY_COMPILE = aufgabe$(exercise).c aufgabe$(exercise).h aufgabe$(exercise): $(DEPENDENCY_COMPILE) gcc -o aufgabe$(exercise) aufgabe$(exercise).c tar: $(DEPENDENCY) mkdir $(GROUP) && mkdir $(GROUP)/Aufgabe$(EXERCISE) && cp *.c *.h Makefile $(DIR)/ && tar -cf $(GROUP)_Aufgabe$(EXERCISE).tar $(DIR)/* && rm $(DIR)/* && rmdir $(GROUP)/Aufgabe$(EXERCISE) && rmdir $(GROUP) Mit diesem Makefile lässt sich nun durch Anpassen des Wertes der Variable EXERCISE und den Abhängigkeiten sowohl das aktuelle Programm compilieren, als auch ein entsprechendes tar-archiv zur Abgabe erstellen.