imported>Aka: /* Einzelnachweise */ bereits in Unterkategorie „Build-Management“ enthalten

2023-03-26T13:59:46Z

Einzelnachweise: bereits in Unterkategorie „Build-Management“ enthalten

Neue Seite

{{SEITENTITEL:make}}
{{Dieser Artikel|behandelt das Build-Management-Tool. Für die Zeitschrift siehe [[Make:]].}}
{{Infobox Software
| Maintainer = diverse
| Hersteller = [[Stuart Feldman]], diverse
| Erscheinungsjahr = 1976<ref>[https://www.princeton.edu/~hos/mike/transcripts/feldman.htm ''Interview with Stu Feldman, 9-20-89''] abgerufen am 22. November 2019.</ref>
| Management =
| AktuelleVersion =
| AktuelleVersionFreigabeDatum =
| AktuelleVorabVersion =
| AktuelleVorabVersionFreigabeDatum =
| Betriebssystem = [[Portable Operating System Interface|POSIX]] ([[Linux]], [[Unix]], …), portiert auf diverse andere Plattformen
| Programmiersprache = [[C (Programmiersprache)|C]]
| Kategorie = [[Erstellungsprozess|Build-Management]]-Tool
| Lizenz = diverse
| Deutsch =
| Website = 
}}

'''make''' ({{enS}} für ''machen'', ''erstellen'') ist ein [[Erstellungsprozess|Build-Management]]-Tool, das Kommandos in Abhängigkeit von Bedingungen ausführt. Es wird hauptsächlich bei der [[Softwareentwicklung]] als [[Programmierwerkzeug]] eingesetzt.<ref name="gnu make">{{Internetquelle |url=https://www.gnu.org/software/make/ |titel=GNU Make |sprache=en |abruf=2018-10-03}}</ref>

Genutzt wird es beispielsweise, um in Projekten, die aus vielen verschiedenen [[Datei]]en mit [[Quellcode]] bestehen, automatisiert alle Arbeitsschritte ([[Compiler|Übersetzung]], [[Linker (Computerprogramm)|Linken]], Dateien kopieren etc.) zu steuern, bis hin zum fertigen, ausführbaren Programm. <code>make</code> ist jedoch so flexibel ausgelegt, dass es auch beliebige andere Aufgaben steuern kann, bei denen die zeitliche Abhängigkeit von Dateien eine Rolle spielt.<ref name="gnu make" />

Das Hilfsprogramm <code>make</code> ist Teil des [[Portable Operating System Interface|POSIX]]-Standards, dessen gegenwärtige Bezeichnung ''[[IEEE]] Std 1003.1, 2008 Edition'' lautet (äquivalent dazu [[Single UNIX Specification]] V3, SUSv3).

== Erklärung ==
<code>make</code> 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 [[Quelltext]]dateien auf welche Weise durch den Compiler oder durch andere Programme zu welchen [[Objektcode|Objektdateien]] bzw. Ergebnissen verarbeitet werden, bzw. welche Objektdateien vom Linker zu [[Programmbibliothek]]en oder ausführbaren [[Computerprogramm|Programmen]] verbunden werden. Alle Schritte erfolgen unter Beachtung der im ''Makefile'' erfassten Abhängigkeiten.<ref name="gnu make" />

Wenn das Makefile vom <code>make</code>-Programm abgearbeitet wird, wird eine [[Konvertierung (Informatik)|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 [[Software-Entwicklung|Entwicklung]] großer Programmpakete mit vielen Quelldateien und vielen ausführbaren Programmen entfällt so die Notwendigkeit, bei einer Reihe kleiner Veränderungen alle [[Kompilierung]]en erneut durchzuführen.<ref name="gnu make" /> 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 <code>[[mkmf]]</code> oder <code>[[makedepend]]</code> 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 <code>make</code> 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.

<code>make</code> 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|Literatur]])''. Daher wurden immer wieder Versuche gemacht, einen Nachfolger zu finden und zu etablieren ''(siehe [[#Alternativen zum make-Befehl|Alternativen]])''.

== Prinzip ==
Das Erstellen einer Datei wird im Makefile als ein Ziel (Target) bezeichnet. Die Randbedingungen dazu werden in einem Eintrag beschrieben.<ref name="gnu make regel">{{Internetquelle |url=https://www.gnu.org/software/make/manual/make.html#Rule-Introduction |titel=GNU Make: What a Rule Looks Like |sprache=en |abruf=2018-10-03}}</ref>

Beispiel:
<syntaxhighlight lang="make">
A: B C
cmd_A
</syntaxhighlight>

Diese Zeile bedeutet: Ziel <code>A</code> hängt von den Quellen <code>B</code> und <code>C</code> ab („Hängt ab von“ bedeutet meistens „wird erstellt aus“).<ref name="gnu make dependensies">{{Internetquelle |url=https://www.gnu.org/software/make/manual/make.html#Simple-Makefile |titel=GNU Make: A Simple Makefile |sprache=en |abruf=2018-10-03}}</ref> Wenn <code>A</code> erstellt werden soll, werden <code>B</code> und <code>C</code> betrachtet. Ist eins von beiden jünger als <code>A</code>, wird <code>cmd_A</code> ausgeführt, um <code>A</code> neu zu erstellen. Ist <code>A</code> jünger als <code>B</code> und <code>C</code>, wird <code>A</code> als aktuell betrachtet und <code>cmd_A</code> daher nicht ausgeführt.

<code>B</code> oder <code>C</code> als Quellen von <code>A</code> können nun wiederum Ziele aus weiteren Make-Vorschriften sein:
<syntaxhighlight lang="make">
B: D E
cmd_B
</syntaxhighlight>

Zuerst wird <code>A</code> betrachtet. Da <code>A</code> von <code>B</code> abhängt, wird also <code>B</code> betrachtet, bevor für <code>A</code> weiteres ausgeführt wird. Insgesamt wird damit die Ausführung von Anweisungen rückwärts beschrieben. Ausgangspunkt ist das letztliche Ziel <code>A</code>.<ref name="gnu make dependensies" /> 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: <code>don't know how to make …</code>. 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 <code>A</code>, <code>B</code> usw. benannte Files mit Verzeichnisangabe sein. Es ist aber auch möglich, unter Angabe der File-Extension allgemeine Regeln zu definieren:
<syntaxhighlight lang="make">
.c.o:
$(CC) $(CFLAGS) -c -o $@ $<
</syntaxhighlight>

Im obigen Beispiel befindet sich eine sogenannte ''Schlussfolgerungsregel'' die in Form einer ''Suffixregel'' verfasst ist.<ref>{{Internetquelle |url=https://www.gnu.org/software/make/manual/make.html#Suffix-Rules |titel=GNU Make: Old-Fashioned Suffix Rules |sprache=en |abruf=2018-10-03}}</ref>

== Beispiel für ein Makefile ==
Das vorliegende Beispiel zeigt lediglich die einfachste Form eines Makefiles. Es gibt darüber hinaus Methoden wie z. B. [[Entwurfsmuster|Pattern]]-Regeln, die das Makefile mächtiger machen.<ref name="gnu make dependensies" />

Ein Programm <code>prog</code> soll aus den beiden Quelldateien <code>foo.c</code> und <code>bar.c</code> so erzeugt werden, dass immer möglichst wenig Übersetzungs- und Bindevorgänge benötigt werden, wenn nur eine der beiden [[Quellcode|Quelldateien]] geändert wird.
<syntaxhighlight line="GESHI_NORMAL_LINE_NUMBERS" lang="make">
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
</syntaxhighlight>
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 <code>foo.o</code> und <code>bar.o</code> 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 <code>LD</code> und einigen Parametern zusammengesetzt. Die beiden Dateien <code>foo.o</code> und <code>bar.o</code> 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 <code>foo.o</code> aus <code>foo.c</code> hergestellt wird, und zwar in der achten Zeile durch Aufruf von <code>cc</code>, 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 <code>make prog</code> gestartet. Wird kein Parameter angegeben, führt <code>make</code> das zuerst definierte Ziel (hier <code>prog</code>) aus. In dem obigen Beispiel hätte also <code>make</code> die gleiche Wirkung wie <code>make prog</code>.

== Anwendung ==
Die Entwicklung großer Programme und Programmpakete, die aus vielen einzelnen Quelltextdateien bestehen und Abhängigkeiten zu separaten Bibliotheken besitzen, ist ohne <code>make</code> 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 [[Compiler|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]].<ref>{{Internetquelle |url=https://www.gnu.org/software/automake/manual/html_node/Autotools-Introduction.html |titel=An Introduction to the Autotools |sprache=en |abruf=2018-10-03}}</ref><ref>{{Internetquelle |url=http://doc.qt.io/qt-5/qmake-manual.html |titel=qmake Manual |sprache=en |abruf=2018-10-03}}</ref><ref>{{Internetquelle |url=https://cmake.org/overview/ |titel=About CMake |sprache=en |abruf=2018-10-03}}</ref> Methoden zur Reduzierung der Komplexität der Makefiles beruhen auf mächtigeren Systemen wie dem Programm [[nmake (Software)|nmake]] von [[David Korn]].<ref>{{Internetquelle |url=https://w3.cs.jmu.edu/bernstdh/Web/common/help/msc_nmake.php |titel=MS C/C++: The nmake Command |sprache=en |abruf=2018-10-03}}</ref> Dieses System ermöglicht Makefiles, die lediglich tabellarisch die beteiligten Quelldateien auflisten.

== Alternativen zum make-Befehl ==
[[GNU Make]] (kurz gmake) wird üblicherweise in Linux eingesetzt, für [[Microsoft Windows|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 <code>make</code>-Problem mit Rekursion kann elegant umgangen werden, um korrekte Aufbauten zu garantieren. Darüber hinaus ist [[Perl (Programmiersprache)|Perl]] auf allen Ebenen integrierbar.<ref>{{Internetquelle |url=http://makepp.sourceforge.net/ |titel=Makepp Home Page |sprache=en |abruf=2018-10-03}}</ref>
; mk
: (unter [[Plan 9 (Betriebssystem)|Plan 9]]) ist ebenfalls aus ''make'' entwickelt, jedoch in die Richtung der Vereinfachung.
; [[SCons]]
: [[Python (Programmiersprache)|Python]]-implementiertes, plattformübergreifendes System mit vielen Verbesserungen gegenüber <code>make</code>. Integriert auch einige Features von <code>automake</code>/<code>autoconf</code>. 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]]
: [[Extensible Markup Language|XML]]-basierende Systeme mit demselben Zweck, die mit Hilfe von [[Java (Programmiersprache)|Java]] erweitert werden können.<ref>{{Internetquelle |url=http://ant.apache.org/ |titel=Apache Ant About |sprache=en |abruf=2018-10-03}}</ref><ref>{{Internetquelle |url=http://maven.apache.org/ |titel=Welcome to Apache Maven |sprache=en |abruf=2018-10-03}}</ref>
; [[Vestasys|Vesta]]
: ist ein [[Software-Configuration-Management|SCM]]-Werkzeug mit integriertem Build Tool.
; Jam
: ein Buildwerkzeug aus der [[Boost (C++-Bibliothek)|Boost]]-Bibliothek, der Erweiterung der C++-Standardbibliothek der Programmiersprache C++.
; [[Rake (Software)|Rake]]
: Ein in [[Ruby (Programmiersprache)|Ruby]] implementiertes Werkzeug mit in Ruby geschriebenen ''Rakefiles''.<ref>{{Internetquelle |url=https://ruby.github.io/rake/ |titel=RAKE – Ruby Make |sprache=en |abruf=2018-10-03}}</ref>
; [[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 [[Concurrent Versions System|CVS]].<ref>{{Internetquelle |url=https://pypi.org/project/Aap/ |titel=PyPI:Aap |sprache=en |abruf=2018-10-03}}</ref>

== 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}}
* {{man|1|make|posix|maintain, update, and regenerate groups of programs}}
* {{man|1|make|OpenBSD|maintain program dependencies}}
* {{man|1|make|FreeBSD|maintain program dependencies}}
* {{man|1|make|gnu|GNU make utility to maintain groups of programs}}
* Peter Miller: [http://aegis.sourceforge.net/auug97.pdf ''Recursive Make Considered Harmful''] (PDF) – beschreibt die Probleme, die durch rekursive Makefiles entstehen können (was ein typisches Vorgehen ist)
* [http://make.paulandlesley.org/autodep.html ''Advanced Auto-Dependency Generation mit make'']
* [http://seed7.sourceforge.net/scrshots/make7.htm ''Make7''] – Ein portables [[Open Source]] make Programm, geschrieben in [[Seed7]] (englisch)

== Einzelnachweise ==
<references responsive />

{{Normdaten|TYP=s|GND=4334388-0|LCCN=n/92/090404|VIAF=176684165}}

[[Kategorie:Unix-Software]]
[[Kategorie:POSIX]]
[[Kategorie:Build-Management]]

Make - Versionsgeschichte

imported>Aka: /* Einzelnachweise */ bereits in Unterkategorie „Build-Management“ enthalten