make
make (englisch für machen, erstellen) ist ein Build-Management-Tool, das Kommandos in Abhängigkeit von Bedingungen ausführt. Es wird hauptsächlich bei der Softwareentwicklung als Programmierwerkzeug eingesetzt.[2]
| Make | |
|---|---|
| Basisdaten | |
| Maintainer | diverse |
| Entwickler | Stuart Feldman, diverse |
| Erscheinungsjahr | 1976[1] |
| Betriebssystem | POSIX (Linux, Unix, …), portiert auf diverse andere Plattformen |
| Programmiersprache | C |
| Kategorie | Build-Management-Tool |
| Lizenz | diverse |
Genutzt wird es beispielsweise, um in Projekten, die aus vielen verschiedenen Dateien mit Quellcode bestehen, automatisiert alle Arbeitsschritte (Übersetzung, Linken, Dateien kopieren etc.) zu steuern, bis hin zum fertigen, ausführbaren Programm. make ist jedoch so flexibel ausgelegt, dass es auch beliebige andere Aufgaben steuern kann, bei denen die zeitliche Abhängigkeit von Dateien eine Rolle spielt.[2]
Das Hilfsprogramm make ist Teil des POSIX-Standards, dessen gegenwärtige Bezeichnung IEEE Std 1003.1, 2008 Edition lautet (äquivalent dazu Single UNIX Specification V3, SUSv3).
Erklärung
make liest ein sogenanntes Makefile (man beachte die Großschreibung, welche bei Unix-Dateisystemen unterschieden wird), in dem die Abhängigkeiten des Übersetzungsprozesses von Programmen formalisiert erfasst sind. Diese Formalisierung beschreibt, welche Quelltextdateien auf welche Weise durch den Compiler oder durch andere Programme zu welchen Objektdateien bzw. Ergebnissen verarbeitet werden, bzw. welche Objektdateien vom Linker zu Programmbibliotheken oder ausführbaren Programmen verbunden werden. Alle Schritte erfolgen unter Beachtung der im Makefile erfassten Abhängigkeiten.[2]
Wenn das Makefile vom make-Programm abgearbeitet wird, wird eine Umwandlung etwa einer Quelldatei in eine Objektdatei nur dann vorgenommen, wenn die Quelldatei neuer als die bereits vorliegende Version der Ergebnisdatei ist, bzw. wenn keine Ergebnisdatei vorhanden ist. Bei der Entwicklung großer Programmpakete mit vielen Quelldateien und vielen ausführbaren Programmen entfällt so die Notwendigkeit, bei einer Reihe kleiner Veränderungen alle Kompilierungen erneut durchzuführen.[2] Der Erfolg dieser Sparmaßnahme hängt von der korrekten Angabe der Dateiabhängigkeiten ab. Alle Abhängigkeiten müssen vollständig und korrekt im Makefile beschrieben sein – was bei großen Projekten nicht leicht zu realisieren ist. Insbesondere bei Programmänderungen oder -erweiterungen können neue Abhängigkeiten entstehen. Zur korrekten Funktion müssen diese Abhängigkeiten in das Makefile eingetragen werden. In den frühen 1980er Jahren wurden dazu häufig Hilfsprogramme wie mkmf oder makedepend verwendet. Seit Mitte der 1980er Jahre gibt es in die Make-Programme integrierte Methoden zur automatischen Erzeugung der Abhängigkeitslisten (z. B. in SunPro make) bzw. in die Makefiles integrierte Regeln zu deren Erzeugung.
Die von make ausgeführten Befehle sind nicht auf Compiler oder Linker beschränkt. Jedes Werkzeug, das der Kommandozeileninterpreter zur Verfügung stellt, kann benutzt werden, um die gewünschten Dateimanipulationen zu erreichen. So kann man z. B. automatisch Bilder aus Texten erzeugen.
make hat sich in großen Bereichen der Software-Entwicklung durchgesetzt, hatte aber bis ca. Mitte der 1980er Jahre – gerade bei großen Projekten – (solange die automatisierte Erzeugung sämtlicher Abhängigkeitsregeln nicht gelöst war) Probleme (siehe Literatur). Daher wurden immer wieder Versuche gemacht, einen Nachfolger zu finden und zu etablieren (siehe Alternativen).
Prinzip
Das Erstellen einer Datei wird im Makefile als ein Ziel (Target) bezeichnet. Die Randbedingungen dazu werden in einem Eintrag beschrieben.[3]
Beispiel:
A: B C
cmd_A
Diese Zeile bedeutet: Ziel A hängt von den Quellen B und C ab („Hängt ab von“ bedeutet meistens „wird erstellt aus“).[4] Wenn A erstellt werden soll, werden B und C betrachtet. Ist eins von beiden jünger als A, wird cmd_A ausgeführt, um A neu zu erstellen. Ist A jünger als B und C, wird A als aktuell betrachtet und cmd_A daher nicht ausgeführt.
B oder C als Quellen von A können nun wiederum Ziele aus weiteren Make-Vorschriften sein:
B: D E
cmd_B
Zuerst wird A betrachtet. Da A von B abhängt, wird also B betrachtet, bevor für A weiteres ausgeführt wird. Insgesamt wird damit die Ausführung von Anweisungen rückwärts beschrieben. Ausgangspunkt ist das letztliche Ziel A.[4] Diese Betrachtung muss bei Quellen enden, die vorhanden sind und für die es keine weitere Bildungsvorschrift gibt. Das sind die eigentlichen Quellen der gesamten Generierung. Ist eine Quelle nicht vorhanden, es wird aber auch keine Bildungsvorschrift gefunden, kann der maker nur mit einer Fehlermeldung reagieren: don't know how to make …. Ursache für einen solchen Fehler kann entweder ein Fehler im Makefile oder das tatsächliche Fehlen der Quelle sein.
Definition von Ableitungsregeln: In der obigen Darstellung können A, B usw. benannte Files mit Verzeichnisangabe sein. Es ist aber auch möglich, unter Angabe der File-Extension allgemeine Regeln zu definieren:
.c.o:
$(CC) $(CFLAGS) -c -o $@ $<
Im obigen Beispiel befindet sich eine sogenannte Schlussfolgerungsregel die in Form einer Suffixregel verfasst ist.[5]
Beispiel für ein Makefile
Das vorliegende Beispiel zeigt lediglich die einfachste Form eines Makefiles. Es gibt darüber hinaus Methoden wie z. B. Pattern-Regeln, die das Makefile mächtiger machen.[4]
Ein Programm prog soll aus den beiden Quelldateien foo.c und bar.c so erzeugt werden, dass immer möglichst wenig Übersetzungs- und Bindevorgänge benötigt werden, wenn nur eine der beiden Quelldateien geändert wird.
CC = cc
LD = ld
prog: foo.o bar.o
$(LD) -o prog foo.o bar.o
foo.o: foo.c
$(CC) -c foo.c
bar.o: bar.c
$(CC) -c bar.c
In den ersten beiden Zeilen werden globale Variablen definiert, welche die Programmnamen für den Compiler und den Linker enthalten. Zeile 4 definiert eine Sprungmarke im Makefile, die targets genannt werden; die Ausdrücke foo.o und bar.o rufen die in den Zeilen 7 und 10 definierten targets zuerst in der angegebenen Reihenfolge auf, bevor letztendlich das Kommando in Zeile 5 ausgeführt wird. In Zeile 5 wird ein Kommando aus der globalen Variable LD und einigen Parametern zusammengesetzt. Die beiden Dateien foo.o und bar.o stehen zur Verfügung, weil zuvor bereits die beiden anderen targets ausgeführt wurden, welche diese Dateien erzeugt haben. Die nächste Zeile gibt an, dass foo.o aus foo.c hergestellt wird, und zwar in der achten Zeile durch Aufruf von cc, dem C-Compiler. Die beiden letzten Zeilen sind analog.
Zwischen den Namen der Sprungmarken und den unter ihnen verarbeiteten Dateien besteht kein zwingender Zusammenhang. Anweisungen, die unter einer Sprungmarke ausgeführt werden, beginnen stets mit einem Horizontal-Tabulatorzeichen.
Der Vorgang wird auf der Kommandozeile mittels make prog gestartet. Wird kein Parameter angegeben, führt make das zuerst definierte Ziel (hier prog) aus. In dem obigen Beispiel hätte also make die gleiche Wirkung wie make prog.
Anwendung
Die Entwicklung großer Programme und Programmpakete, die aus vielen einzelnen Quelltextdateien bestehen und Abhängigkeiten zu separaten Bibliotheken besitzen, ist ohne make oder ähnliche Hilfsmittel kaum mehr denkbar. In der Welt des Open Source ist es üblich, dass mit dem Quellcode eines Projekts auch das Makefile veröffentlicht wird, um das Kompilieren einer Software zu vereinfachen.
Neuere Entwicklungen
Besonders bei größeren Programmen wird das Makefile von den Entwicklern nicht immer direkt geschrieben, sondern entweder mittels unterschiedlicher Programme aus einfacheren Regeln erstellt oder es werden mächtigere Systeme verwendet. Eine Methode zur automatischen Erzeugung von komplexen Makefiles ist die Verwendung von Präprozessoren wie den GNU autotools (autoconf und automake) oder auch mkmf, qmake oder CMake.[6][7][8] Methoden zur Reduzierung der Komplexität der Makefiles beruhen auf mächtigeren Systemen wie dem Programm nmake von David Korn.[9] Dieses System ermöglicht Makefiles, die lediglich tabellarisch die beteiligten Quelldateien auflisten.
Alternativen zum make-Befehl
GNU Make wird üblicherweise in Linux eingesetzt, für Windows gibt es nmake. Als Nachfolger von UNIX-make wurde nmake von AT&T geschrieben, es ermöglicht einfache tabellarische Makefiles.
- makepp
- ist zwar ebenfalls ein Derivat von GNU make, bietet aber darüber hinaus einen integrierten erweiterbaren Befehls- und Include-Parser um implizite Abhängigkeiten automatisch zu erkennen. Auch geänderte Befehlsoptionen u. ä. Rahmenbedingungen werden erkannt. Das große
make-Problem mit Rekursion kann elegant umgangen werden, um korrekte Aufbauten zu garantieren. Darüber hinaus ist Perl auf allen Ebenen integrierbar.[10] - mk
- (unter Plan 9) ist ebenfalls aus make entwickelt, jedoch in die Richtung der Vereinfachung.
- SCons
- Python-implementiertes, plattformübergreifendes System mit vielen Verbesserungen gegenüber
make. Integriert auch einige Features vonautomake/autoconf. Seine Stärke kommt daher, dass in den „SConstruct“ genannten Makefiles die gesamte Funktionalität der Programmiersprache Python genutzt werden kann. - Apache Ant und Apache Maven
- XML-basierende Systeme mit demselben Zweck, die mit Hilfe von Java erweitert werden können.[11][12]
- Vesta
- ist ein SCM-Werkzeug mit integriertem Build Tool.
- Jam
- ein Buildwerkzeug aus der Boost-Bibliothek, der Erweiterung der C++-Standardbibliothek der Programmiersprache C++.
- Rake
- Ein in Ruby implementiertes Werkzeug mit in Ruby geschriebenen Rakefiles.[13]
- A-A-P
- ein in Python geschriebenes Programm zur Automatisierung der Erstellung von Computerprogrammen, vergleichbar mit make oder Ant. Neben der klassischen Automatisierung des Erstellungsvorgangs ermöglicht es auch das Auffinden, Herunterladen, Installieren und Verändern von sowie die Fehlersuche in Computerprogrammen. A-A-P besitzt eine integrierte Anbindung an CVS.[14]
Literatur
- Helmut Herold: make. Addison-Wesley, ISBN 3-8273-2095-X
- Thomas Peschel-Findeisen: Make ge-packt. Mitp-Verlag, ISBN 3-8266-1442-9
- Robert Mecklenburg: GNU make. O’Reilly, ISBN 3-89721-408-3
Weblinks
make(1): maintain, update, and regenerate groups of programs – Open Group Base Specificationmake(1): maintain program dependencies – OpenBSD General Commands Manualmake(1): maintain program dependencies – FreeBSD General Commands Manualmake(1): GNU make utility to maintain groups of programs – Debian GNU/Linux Ausführbare Programme oder Shell-Befehle Handbuchseite- Peter Miller: Recursive Make Considered Harmful (PDF) – beschreibt die Probleme, die durch rekursive Makefiles entstehen können (was ein typisches Vorgehen ist)
- Advanced Auto-Dependency Generation mit make
- Make7 – Ein portables Open Source make Programm, geschrieben in Seed7 (englisch)
Einzelnachweise
- Interview with Stu Feldman, 9-20-89 abgerufen am 22. November 2019.
- GNU Make. Abgerufen am 3. Oktober 2018 (englisch).
- GNU Make: What a Rule Looks Like. Abgerufen am 3. Oktober 2018 (englisch).
- GNU Make: A Simple Makefile. Abgerufen am 3. Oktober 2018 (englisch).
- GNU Make: Old-Fashioned Suffix Rules. Abgerufen am 3. Oktober 2018 (englisch).
- An Introduction to the Autotools. Abgerufen am 3. Oktober 2018 (englisch).
- qmake Manual. Abgerufen am 3. Oktober 2018 (englisch).
- About CMake. Abgerufen am 3. Oktober 2018 (englisch).
- MS C/C++: The nmake Command. Abgerufen am 3. Oktober 2018 (englisch).
- Makepp Home Page. Abgerufen am 3. Oktober 2018 (englisch).
- Apache Ant About. Abgerufen am 3. Oktober 2018 (englisch).
- Welcome to Apache Maven. Abgerufen am 3. Oktober 2018 (englisch).
- RAKE – Ruby Make. Abgerufen am 3. Oktober 2018 (englisch).
- PyPI:Aap. Abgerufen am 3. Oktober 2018 (englisch).