make

make (engl. machen, erstellen) ist ein Computerprogramm, das Kommandos in Abhängigkeit von Bedingungen ausführt. Es wird hauptsächlich bei der Softwareentwicklung als Programmierwerkzeug eingesetzt.

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 so mächtig, dass es nicht nur zur automatisierten Steuerung der Übersetzung geeignet ist, sondern beliebige Aufgaben übernehmen kann, bei denen die zeitliche Abhängigkeit von Dateien eine Rolle spielt.

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, 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.

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. Der Erfolg dieser Sparmaßnahme hängt natürlich 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 sofort 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.

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“.) 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. 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 Ableitungs-Regeln: 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.

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.

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.

1. CC = cc
   

2. LD = ld
   

4. prog: foo.o bar.o
   

5.  $(LD) -o prog foo.o bar.o
   

7. foo.o: foo.c
   

8.        $(CC) -c foo.c
   

10. bar.o: bar.c
    

11.    $(CC) -c bar.c
    

In den ersten beiden Zeilen wird angegeben, mit welchen Programmen die Kompilierung und das Linken ausgeführt werden sollen (diese beiden Definitionen sind normalerweise unnötig, weil sie im Make-Programm integriert sind). Die vierte Zeile bedeutet, dass das Programm prog aus den Teilen foo.o und bar.o hergestellt wird. Die darauffolgende Zeile gibt an, wie mit welchem Werkzeug – hier ein Linker – dies erfolgen soll. Zeilen, die – wie in diesem Fall – Programme aufrufen, müssen mit einem Tabulatorzeichen beginnen. 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.

Der Vorgang wird dann 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 Quelltext-Dateien 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.

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 die GNU autotools (autoconf und automake) oder auch mkmf, qmake oder CMake. Methoden zur Reduzierung der Komplexizität der Makefiles beruhen auf mächtigeren Systemen wie dem Programm nmake von David Korn oder dem Makefilesystem von Jörg Schilling. Beide Systeme ermöglichen Makefiles, die lediglich tabellarisch die beteiligten Quell-Dateien auflisten.

Alternativen zum make-Befehl

(ohne Anspruch auf Vollständigkeit)

UNIX-Derivate

Derivate in unixoiden Systemen sind GNU Make, smake (Jörg Schilling), nmake (Microsoft), Turbo Make (Borland), JMake und Opus Make.

Nachfolger von UNIX-make

nmake (AT&T) wurde als Nachfolger von UNIX-make geschrieben und ermöglicht sehr 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.

mk

(unter Plan9) 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 von automake/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.

Vesta

ist ein SCM-Werkzeug mit integriertem Build Tool.

Jam

ein Buildwerkzeug aus der Boost-Bibliothek, der Erweiterung der C++-Standardbibliothek der Programmiersprache C++.

Rant

Ein in Ruby implementiertes Werkzeug, auch die Makefiles werden in Ruby geschrieben.

Rake

Ebenfalls in Ruby implementiertes Werkzeug mit in Ruby geschriebenen Rakefiles.

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.

Yabu

eine Weiterentwicklung von make mit ähnlichem Dateiformat. Es ist besonders für multi-Plattform-Builds geeignet und kann Builds parallel auf mehreren Rechnern ausführen.

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

 Wiktionary: make – Bedeutungserklärungen, Wortherkunft, Synonyme, Übersetzungen

• make(1) – Linux-Manpage (Englisch)
• Peter Miller: Recursive Make Considered Harmful – 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 [Englisch]