make

aus Wikipedia, der freien Enzyklopädie

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

Genutzt wird es beispielsweise, um in einem Projekt, das aus vielen verschiedenen Dateien mit Quellcode besteht, automatisiert alle Arbeitsschritte (Übersetzung, Linken, Dateien kopieren etc.) zu steuern, bis hin zum fertigen, ausführbaren Programm.

Inhaltsverzeichnis 1 Erklärung 2 Prinzip 3 Beispiel für ein Makefile 4 Umfeld 5 Probleme 6 Alternativen zum make-Befehl 7 Literatur 8 Weblinks

[Bearbeiten] Erklärung

make liest ein sogenanntes Makefile, in dem der Übersetzungsprozess von Programmen formalisiert erfasst ist. Diese Formalisierung beschreibt, welche Quelltextdateien der Compiler zu welchen Objektdateien verarbeitet, und welche Objektdateien vom Linker dann zu Programmbibliotheken oder ausführbaren Programmen verbunden werden. Alle Schritte erfolgen unter Beachtung der Abhängigkeiten, die möglicherweise durch die Dateiorganisation gegeben sein können.

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 Objektdatei 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 Compilationen 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. Diese müssen sofort im Makefile eingetragen werden. Dies wird durch Hilfsprogramme wie mkmf unterstützt.

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, hat aber – gerade bei großen Projekten – einige Probleme (siehe Literatur). Daher wurden immer wieder Versuche gemacht, einen Nachfolger zu finden und zu etablieren (siehe Alternativen).

[Bearbeiten] 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
     D

Diese Zeile bedeutet: Ziel A hängt von den Zielen 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 D ausgeführt, um A neu zu erstellen. Ist A jünger als B und C, wird A als aktuell betrachtet.

[Bearbeiten] Beispiel für ein Makefile

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.obj bar.obj
        $(LD) -o prog foo.obj bar.obj

foo.obj: foo.c
        $(CC) -c foo.c

bar.obj: bar.c
        $(CC) -c bar.c

In den ersten beiden Zeilen wird angegeben, mit welchen Programmen die Kompilierung und das Linken ausgeführt werden sollen. Die dritte Zeile bedeutet, dass das Programm prog aus den Teilen foo.obj und bar.obj 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.obj aus foo.c hergestellt wird, und zwar in der sechsten Zeile durch Aufruf von cc, dem C-Kompiler. 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.

Das vorliegende Beispiel zeigt lediglich die einfachste Form eines Makefiles, es gibt Methoden wie z. B. Patternregeln, die das Makefile mächtiger machen.

[Bearbeiten] Umfeld

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 versteht es sich von selbst, dass mit dem Quellcode eines Projekts auch das Makefile veröffentlicht wird.

Besonders bei größeren Programmen wird das Makefile von den Entwicklern nicht direkt geschrieben, sondern mittels unterschiedlicher Programme aus einfacheren Regeln erstellt. Hierzu werden üblicherweise die GNU autotools wie autoconf und automake oder auch mkmf oder qmake verwendet. Die Compiler für C und C++ aus der GNU Compiler Collection geben die Abhängigkeiten der Programme von ihren Header-Dateien an (Option -M).

[Bearbeiten] Probleme

In make-gesteuerten Projekten werden meist Abhängigkeiten in Dateien gespeichert. Diese Dateien beinhalten z. B. Informationen darüber, welche C-/CPP-Datei welche Headerdatei einbindet. Dadurch wird gewährleistet, dass durch Änderung einer Headerdatei auch nur die Dateien neu übersetzt werden, welche diese Headerdateien verwenden. Diese Abhängigkeitsdateien werden in der Regel jeweils beim Übersetzen der einzelnen Dateien erzeugt und folgend in das Makefile (siehe oben) includiert.

Erfährt ein großes Softwareprojekt grobe Änderungen, die die Löschungen von Headerdateien beinhalten, kann ein Aufruf von make zu einem Fehler führen, da die Abhängigkeiten für eine Objektdatei eventuell nicht mehr erfüllt sind. Die Abhängigkeitsdateien für die betroffene(n) Objektdatei(en) beziehen sich auf die reellen Abhängigkeiten vor der Änderung.

Dieses Problem ist rein logisch und kein Fehler/Bug von make an sich. Der Entwickler/User löst dieses Problem durch den Aufruf von make clean, durch das entsprechende Abhängigkeitsdateien und alle Objektdateien sowie Binaries gelöscht werden, was einen weiteren Aufruf von make dazu veranlasst, alles neu zu kompilieren.

In einer Entwicklungsumgebung stellt dies kein Problem dar. In einer automatisierten Umgebung (z. B. Build Server) muss dies durch die erstellende Software berücksichtigt und abgefangen werden.

[Bearbeiten] Alternativen zum make-Befehl

(erhebt keinen Anspruch auf Vollständigkeit)

• Derivate von make sind z. B. GNU Make, nmake (Microsoft), Turbo Make (Borland), JMake, Opus Make, CMake.
• makepp ist zwar 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.
• 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 ist 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.
• In einer integrierten Entwicklungsumgebung (IDE) wird das Ganze in eine grafische Benutzeroberfläche verpackt und ist subjektiv leichter zu handhaben. IDEs gibt es für fast jede verbreitete Sprache (C/C++, Java, etc.) und jedes bedeutende Betriebssystem.
• AAP
• Cook von Peter Miller (s. auch Weblinks)
• Yabu ist 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.

[Bearbeiten] 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

[Bearbeiten] Weblinks

• make(1) – Linux-Manpage (englisch)
• Peter Miller: Recursive Make Considered Harmful – Beschreibt die Probleme durch rekursive 'makefiles' (was ein typisches Vorgehen ist).
• Deutsches Tutorial: http://www.ijon.de/comp/tutorials/makefile.html
• Deutsches Tutorial: http://de.linwiki.org/index.php/Make
• ftp://ftp.gnu.org/gnu/make/