Machen (Software)

Machen
Paradigma Makro, deklarativ
Entworfen von Stuart Feldman
Erstmals erschienen April 1976; Vor 46 Jahren
Implementierungssprache C
OS Unix-artig, Inferno
Dateiformate Makefile
Haupt Implementierungen
BSD, GNU, Nmake
Dialekte
BSD make, gnu make, microsoft nmake
Beeinflusst
Ameise, Rechen, MSBUILD, und Andere

Im Software-Entwicklung, Machen ist ein Automatisierung bauen Werkzeug, das automatisch baut ausführbare Programme und Bibliotheken aus Quellcode durch Lesen Dateien genannt Makefiles die angeben, wie das Zielprogramm abgeleitet wird. Obwohl Integrierte Entwicklungsumgebungen und Sprache-Spezifisch Compiler Funktionen können auch verwendet werden, um einen Build -Prozess zu verwalten und bleibt weit verbreitet, insbesondere in Unix und Unix-artig Betriebssysteme.

Neben dem Erstellen von Programmen kann Make verwendet werden, um ein Projekt zu verwalten, bei dem einige Dateien automatisch von anderen aktualisiert werden müssen, wenn sich die anderen ändern.

Herkunft

Es gibt jetzt eine Reihe von Deponcy-Tracking-Versorgungsunternehmen UnixBeginnend mit dem PWB/UNIX 1.0 mit einer Vielzahl von Tools, die auf Softwareentwicklungsaufgaben abzielten.[1] Es wurde ursprünglich geschaffen von Stuart Feldman im April 1976 bei Bell Labs.[2][3][1] Feldman erhielt die 2003 ACM Software System Award Für das Genehmigung dieses weit verbreiteten Tools.[4]

Feldman wurde inspiriert, die Erfahrung eines Kollegen zu schreiben, um ein Programm von ihm zu debugieren, bei dem die ausführbare Datei versehentlich mit Änderungen aktualisiert wurde:

Ursprung mit einem Besuch von Steve Johnson (Autor von YACC usw.), stürmte in mein Büro, verfluchte die Schicksale, die ihn dazu veranlasst hatten, ein morgendliches Debuggen eines korrekten Programms zu verschwenden cc *.o war daher nicht betroffen). Da ich einen Teil des Vorabends verbracht hatte, um mit der gleichen Katastrophe mit einem Projekt umzugehen, an dem ich gearbeitet hatte, war die Idee eines Tools zur Lösung von ihm auftrat. Es begann mit einer aufwändigen Vorstellung eines Abhängigkeitsanalysators, das auf etwas viel einfacheres zurückzuführen war und an diesem Wochenende in die Make -machte. Die Verwendung von Tools, die noch nass waren, war Teil der Kultur. Makefiles waren Textdateien, keine magisch codierten Binärdateien, denn das war das Unix -Ethos: druckbare, debuggierbare, verständliche Dinge.

-Stuart Feldman, Die Kunst der Unix -Programmierung, Eric S. Raymond 2003

Vor der Einführung von Make bestand das Unix -Build -System am häufigsten aus Betriebssystem Abhängige "make" und "installieren" Shell -Skripte, die die Quelle ihres Programms begleiten. Es war ein wichtiger Schritt in Richtung moderner Build -Umgebungen, die Befehle für die verschiedenen Ziele in eine einzelne Datei zu kombinieren und die Abhängigkeitsverfolgung und Archivhandhabung abstrahieren zu können.

Derivate

Screenshot von GNU Make, eine Implementierung von Make

Machen ist eine Reihe von durchgemacht neu schreiben, einschließlich einer Reihe von From-Scratch-Varianten, die dasselbe Dateiformat und grundlegende algorithmische Prinzipien verwendeten und auch eine Reihe ihrer eigenen nicht standardmäßigen Verbesserungen lieferten. Einige von ihnen sind:

  • Sun Devpro Make erschien 1986 mit Sunos-3.2. Mit Sunos-3.2 wurde es als optionales Programm geliefert; Mit Sunos-4.0 wurde SunPro Make das Standard-Make-Programm gemacht.[5] Im Dezember 2006 wurde Sun Devpro Make im Rahmen der Bemühungen um Open-Source Open Source gemacht Solaris.[6][7]
  • Dmake oder Distributed Make, das mit Sun Solaris Studio als standardmäßiger Made geliefert wurde, jedoch nicht die Standardeinstellung auf dem Solaris -Betriebssystem (Sunos). Es war ursprünglich erforderlich, OpenOffice aufzubauen, aber im Jahr 2009[8] Das Build -System wurde neu geschrieben, um GNU -Marke zu verwenden. Während Apache OpenOffice enthält immer noch eine Mischung aus beiden Build -Systemen,[9] die viel aktiver entwickelten Libreoffice verwendet jetzt nur das modernisierte "Gbuild".[8]
  • BSD Machen (PMAKE,[10] Bmake[11] oder Vornähte[12]), das aus Adam de Boors Arbeiten an einer Version von Make -fähig ist, Ziele in der Lage zu erstellen parallelund überlebt mit unterschiedlichem Modifikationsgraden in Freebsd,[11] Netbsd[13] und OpenBSD.[14] Unterscheidungsmerkweise hat es Bedingungen und iterative Schleifen, die in der Parsenstufe angewendet werden und die Makefile konditionell und programmatisch konstruieren können.[15] einschließlich der Erzeugung von Zielen zur Laufzeit.
  • GNU Machen (kurz Gmake) ist die Standardimplementierung von Make for Linux und MacOS.[16] Es bietet mehrere Erweiterungen gegenüber der ursprünglichen Marke, wie z. B. Bedingungen. Es bietet auch viele integrierte Funktionen, mit denen die Notwendigkeit von Shell-Scriting in den Makefile-Regeln beseitigt werden muss und die in der Makefile verwendeten Variablen manipuliert und verwendet werden können.[17] Zum Beispiel die für jeden Funktion kann verwendet werden, um eine Liste von Werten zu iterieren, z. B. die Namen von Dateien in einem bestimmten Verzeichnis.[18] GNU MAIME ist für den Aufbau vieler Softwaresysteme erforderlich, einschließlich GCC (Seit Version 3.4[19]), der Linux -Kernel,[20][21] Apache OpenOffice,[9] Libreoffice,[8] und Mozilla Firefox.[22]
  • Rocky Bernsteins Remake[23] ist eine Gabel von GNU-Make und bietet mehrere Erweiterungen gegenüber GNU, wie z. B. eine bessere Position und Fehlerlokation, Ausführungsverfolgung, Ausführungsprofilierung und einen Debugger.
  • Glenn Fowlers nmake[24] Hat nicht mit dem gleichnamigen Microsoft -Programm verbunden. Sein Eingang ist ähnlich wie bei Make, aber nicht kompatibel. Dieses Programm bietet Verknüpfungen und integrierte Funktionen, die nach seinen Entwicklern die Größe von Makefiles um den Faktor 10 verringern.
  • Microsoft nmake, ein Befehlszeilen-Tool, das normalerweise Teil von ist Visual Studio.[25] Es unterstützt Preprozessor-Direktiven, wie z.[26][27] Inferenzregeln unterscheiden sich von Make; Zum Beispiel können sie Suchpfade einbeziehen.[28] Das Maschetool mitgeliefert mit Embarcadero Products verfügt über eine Befehlszeilenoption, die "die Ursachen für die Nachahmung von Microsofts NMake machen".[29] QT -Projekt's Jom Werkzeug ist ein Klon von Nmake.[30]
  • Mk ersetzt machen in Forschung Unixab Version 9.[31] Eine Neugestaltung des ursprünglichen Tools des Bell Labs -Programmierers Andrew G. Hume verfügt über eine andere Syntax. MK wurde zum Standard -Build -Tool in Plan 9, Bell Labs 'beabsichtigter Nachfolger von Unix.[32]
  • Kati Wird Google ersetzt von GNU make, verwendet in Android OS baut. Es übersetzt das Makefile in Ninja für schnellere inkrementelle Builds.[33]
  • Snakemake ist eine pythongetriebene Implementierung zum Kompilieren und Laufen Bioinformatik Workflows.[34]

Posix Beinhaltet die Standardisierung der grundlegenden Merkmale und des Betriebs des Make-Nutzens und wird mit unterschiedlichen Vollständigkeit in Unix-basierten Versionen von Make implementiert. Im Allgemeinen können einfache Makefiles zwischen verschiedenen Versionen von Make mit angemessenem Erfolg verwendet werden. GNU MAIME, MAKEPP und einige Versionen von BSD sind standardmäßig für Dateien mit dem Namen "Gnumakefile" sucht.[35] "Makeppfile"[36] und "bsdmakeFile"[37] Dies kann es ermöglicht, Makefiles zu setzen, die implementierungsdefiniertes Verhalten an getrennten Orten verwenden.

Verhalten

Make wird normalerweise verwendet bauen Ausführbare Programme und Bibliotheken aus dem Quellcode. Im Allgemeinen gilt die Marke jedoch für jeden Prozess, bei dem beliebige Befehle ausgeführt werden, um eine Quelldatei in ein Zielergebnis zu verwandeln. Zum Beispiel könnte Make verwendet werden, um eine Änderung an einer Bilddatei (der Quelle) zu erkennen, und die Transformationsaktionen könnten darin bestehen, die Datei in ein bestimmtes Format zu konvertieren, das Ergebnis in ein Content-Management-System zu kopieren und dann E-Mail zu senden zu einem vordefinierten Mengen von Benutzern, die angeben, dass die oben genannten Aktionen ausgeführt wurden.

Make wird mit einer Liste von Zieldateinamen aufgerufen, die er erstellen soll Kommandozeilenargumente:

machen [ZIEL ...]

Machen Sie ohne Argumente das erste Ziel, das in seinem Makefile erscheint, was traditionell ein symbolisches "falsches" Ziel namens ist alle.

Make entscheiden, ob ein Ziel durch Vergleich der Dateiänderungszeiten regeneriert werden muss.[38] Dies löst das Problem, das Erstellen von Dateien zu vermeiden, die bereits auf dem neuesten Stand sind, aber es schlägt fehl, wenn sich eine Datei ändert, aber ihre Änderungszeit in der Vergangenheit bleibt. Solche Änderungen könnten durch Wiederherstellung einer älteren Version einer Quelldatei verursacht werden oder wenn a Netzwerkdateisystem ist eine Quelle für Dateien und seine Uhr oder Zeitzone wird nicht mit der Maschine ausgeführt. Der Benutzer muss diese Situation bewältigen, indem er einen vollständigen Build erzwingt. Wenn die Änderungszeit einer Quelldatei in der Zukunft in Zukunft liegt, löst sie unnötige Wiederaufbauung aus, was die Benutzer möglicherweise Unannehmlichkeiten stören kann.

Makefiles werden traditionell zum Kompilieren von Code ( *.c, *.cc, *.c usw.) verwendet, können aber auch für die Bereitstellung von Befehlen zur Automatisierung gemeinsamer Aufgaben verwendet werden. Ein solches Makefile wird aus der Befehlszeile aufgerufen:

machen # Ohne Argument läuft das erste Ziel machen Hilfe  # Verfügbare Ziele anzeigen dist # Machen Sie ein Release -Archiv aus Current Dir

Makefile

Suchen Sie das aktuelle Verzeichnis für die Verwendung von Makefile, z. GNU erstellen Suchdateien in der Reihenfolge einer Datei mit dem Namen einer von Gnumakefile, Makefile, oder Makefile und führt dann das angegebene (oder Standard-) Ziel (en) aus (nur) dieser Datei aus.

Die Makefile -Sprache ähnelt der deklarative Programmierung.[39][40][41] Diese Sprachklasse, in der die notwendigen Endbedingungen beschrieben werden, aber die Reihenfolge, in der Maßnahmen ergriffen werden sollen Imperative Programmierung.

Ein Problem in Automatisierung bauen ist die Anpassung eines Build -Prozesses auf eine gegebene Plattform. Zum Beispiel akzeptiert der auf einer Plattform verwendete Compiler möglicherweise nicht die gleichen Optionen wie die, die auf einer anderen verwendet werden. Dies wird nicht gut von Make behandelt. Dieses Problem wird in der Regel durch Generieren von plattformspezifischen Build-Anweisungen behandelt, die wiederum durch Make verarbeitet werden. Gemeinsame Werkzeuge für diesen Prozess sind Autoconf, Cmake oder Gyp (oder fortgeschrittener Ng).

Makefiles können fünf Arten von Dingen enthalten:[42]

  1. Ein Explizite Regel Sagt, wann und wie man eine oder mehrere Dateien neu erstellt, die als Ziele der Regel bezeichnet werden. Es listet die anderen Dateien auf, von denen die Ziele abhängen, die Voraussetzungen des Ziels bezeichnen, und geben möglicherweise auch ein Rezept zum Erstellen oder Aktualisieren der Ziele an.
  2. Ein implizite Regel Sagt, wann und wie eine Klasse von Dateien basierend auf ihren Namen neu gestaltet werden soll. Es beschreibt, wie ein Ziel von einer Datei mit einem ähnlichen Namen abhängt, das dem Ziel ähnelt, und gibt ein Rezept zum Erstellen oder Aktualisieren eines solchen Ziels.
  3. A Variable Definition ist eine Zeile, die einen Textzeichenwert für eine Variable angibt, die später in den Text eingesetzt werden kann.
  4. A Richtlinie ist eine Anweisung für Make, etwas Besonderes beim Lesen des Makefile zu tun, z. B. das Lesen eines anderen Makefile.
  5. Zeilen beginnen mit # werden für Kommentare.

Regeln

Ein Makefile besteht aus Regeln. Jede Regel beginnt mit einem Text Abhängigkeitslinie das definiert a Ziel gefolgt von einem Colon (:) und optional eine Aufzählung von Komponenten (Dateien oder andere Ziele), von denen das Ziel abhängt. Die Abhängigkeitslinie ist so angeordnet, dass das Ziel (linke Hand des Dickdarms) von Komponenten (rechte Hand des Dickdarms) abhängt. Es ist üblich, Komponenten als Voraussetzungen des Ziels zu bezeichnen.[43] 

Ziel [Ziel ...]: [Komponente ...]Tab ↹[Befehl 1]. . .Tab ↹[Befehl n]

Normalerweise hat jede Regel ein einzigartiges Ziel und nicht mehrere Ziele.

Zum Beispiel a C .o -Objektdatei wird aus .c -Dateien erstellt, sodass .C -Dateien zuerst stehen (d. H. Spezifisch Objektdatei Ziel hängt von einer C -Quelldatei und ab Header -Dateien). Da sich selbst verschiedene Arten von Dateien versteht, erkennt oder unterscheidet, eröffnet dies eine Möglichkeit für menschliches Fehler. Eine vergessene oder eine zusätzliche Abhängigkeit ist möglicherweise nicht sofort offensichtlich und kann zu subtilen Fehler in der generierten Software führen. Es ist möglich, Makefiles zu schreiben, die diese Abhängigkeiten generieren, indem sie Drittanbieter-Tools und einige Makefile-Generatoren wie die anrufen Automake Toolchain zur Verfügung gestellt von der GNU -Projekt, kann dies automatisch tun.

Jede Abhängigkeitszeile kann von einer Reihe von Befehlszeilen von Registerkarten eingerichtet werden, in denen definiert wird, wie die Komponenten (normalerweise Quelldateien) in das Ziel (normalerweise die "Ausgabe") umwandelt werden. Wenn eine der Voraussetzungen eine neuere Änderungszeit als das Ziel hat, werden die Befehlszeilen ausgeführt. Die Dokumentation in GNU bezieht sich auf die Befehle, die mit einer Regel als "Rezept" verbunden sind.

Der erste Befehl kann nach den Voraussetzungen in derselben Zeile erscheinen, getrennt durch ein Semikolon,

Ziele : Voraussetzungen; Befehl

zum Beispiel,

hallo:; @Echo "hallo"

Machen können entscheiden, wo man anfangen soll Topologische Sortierung.

Jede Befehlszeile muss mit a beginnen Tab -Zeichen als Befehl erkannt werden. Die Registerkarte ist a Whitespace Charakter, aber der Weltraumcharakter Hat nicht die gleiche besondere Bedeutung. Dies ist problematisch, da es möglicherweise keinen visuellen Unterschied zwischen einer Registerkarte und einer Reihe von Raumschiffen gibt. Dieser Aspekt der Syntax von Makefiles unterliegt häufig kritisiert; es wurde von beschrieben von Eric S. Raymond als "eines der schlimmsten Designbäder in der Geschichte der Unix"[44] und Das UNIX-HATERS-Handbuch sagte: "Die Verwendung von Registerkarten als Teil der Syntax ist wie eine dieser Pungee -Stick -Fallen in Die grünen Baskenmützen". Feldman erklärt die Entscheidung, wie durch a verursacht wird Problemumgehung für eine frühzeitige Umsetzung Schwierigkeit, die durch den Wunsch nach erhalten bleibt Rückwärtskompatibilität Mit den ersten Benutzern:

Warum die Registerkarte in Spalte 1? Yacc war neu, Lex war brandneu. Ich hatte es auch nicht versucht, also dachte ich, dass dies eine gute Entschuldigung für das Lernen sein würde. Nachdem ich mich mit meinem ersten Stich bei Lex knurrte, habe ich einfach etwas Einfaches mit dem Muster Newline-Tab gemacht. Es hat funktioniert, es blieb. Und dann, ein paar Wochen später, hatte ich eine Benutzerbevölkerung von etwa einem Dutzend, die meisten von ihnen, und ich wollte meine eingebettete Basis nicht vermasseln. Der Rest ist leider Geschichte.

-Stuart Feldman[44]

Die GNU -Maschine ermöglicht jedoch, dass Version 3.82 jedes Symbol (ein Zeichen) als Rezeptpräfix unter Verwendung der .recipePrefix -Spezialvariablen aus auswählen, zum Beispiel:

.Recipeprefix : =:alle: :@Echo "Das Rezept -Präfix -Symbol ist auf '$ (. Rezeprefix)' gesetzt."

Jeder Befehl wird von einem separaten ausgeführt Hülse oder Befehlszeilen-Interpreter Beispiel. Da Betriebssysteme unterschiedliche Befehlszeileninterpretspieler verwenden, kann dies zu unportierbaren Makefiles führen. Zum Beispiel führt GNU make (alle posix make) standardmäßig Befehle mit aus /bin/sh, wo Unix Befehle wie CP werden normalerweise verwendet. Im Gegensatz dazu von Microsoft's nmake führt Befehle mit cmd.exe aus, wo Charge Befehle wie Kopieren sind verfügbar, aber nicht unbedingt CP.

Eine Regel kann keine Befehlszeilen definiert haben. Die Abhängigkeitslinie kann ausschließlich aus Komponenten bestehen, die sich auf Ziele beziehen, z. B.:

Realclean: sauber Distclean

Die Befehlszeilen einer Regel sind normalerweise so angeordnet, dass sie das Ziel generieren. Ein Beispiel: wenn Datei.html ist neuer, es wird in Text konvertiert. Der Inhalt des Makefile:

Datei.txt: Datei.html lynx -dump file.html> file.txt

Die obige Regel wird ausgelöst, wenn Updates "Datei.txt" erstellen. Im folgenden Aufruf würden in der Regel diese Regel verwenden, um das Ziel "Datei.txt" zu aktualisieren, wenn "Datei.html" neuer wäre.

Datei.txt machen

Befehlszeilen können einen oder mehrere der folgenden drei Präfixe haben:

  • a Bindestrich-Minus (-) Angeben, dass Fehler ignoriert werden
  • ein bei Zeichen (@) Angeben, dass der Befehl nicht in die Standardausgabe gedruckt wird, bevor er ausgeführt wird
  • a Pluszeichen (+), der Befehl wird ausgeführt, auch wenn die Marke im Modus "Nicht ausführen" aufgerufen wird

Das Ignorieren von Fehlern und Stummschalten kann alternativ über die speziellen Ziele erhalten werden .IGNORE und .SILENT.[45]

Microsofts NMAKE hat vordefinierte Regeln, die aus diesen Makefiles weggelassen werden können, z. c.obj $(CC)$(CFLAGS).

Makros

Ein Makefile kann Definitionen von Makros enthalten. Makros werden normalerweise als als bezeichnet Variablen Wenn sie einfache String -Definitionen halten, wie CC=clang. Makros in Makefiles können in der überschrieben werden Kommandozeilenargumente übergeben an das Versorgungsunternehmen. Umgebungsvariablen sind auch als Makros erhältlich.

Mit Makros können Benutzer die aufgerufenen Programme und andere benutzerdefinierte Verhaltensweisen während des Erstellungsprozesses angeben. Zum Beispiel das Makro CC wird häufig in Makefiles verwendet, um auf den Ort von a zu verweisen C Der Compiler und der Benutzer möchten möglicherweise einen bestimmten Compiler angeben.

Neue Makros (oder einfache "Variablen") werden traditionell mit Großbuchstaben definiert:

MAKRO = Definition

Ein Makro wird durch Erweiterung verwendet. Traditionell geschieht dies, indem der Name im Inneren eingeschlossen ist $(). (Weglassen, dass die Klammern die Interpretation des nächsten Buchstabens nach dem führt $ Wie der gesamte variable Name.) Eine äquivalente Form verwendet eher lockige Klammern als Klammern, d.h. ${}, was ist der Stil, der in der verwendet wird BSDS.

NEW_MACRO = $ (MAKRO)-$ (MACRO2)

Makros können aus Shellbefehlen bestehen, indem sie die verwenden Befehlssubstitution Bediener, gekennzeichnet durch Backknöpfe (`).

Yjyymmdd  = ` Datum `

Der Inhalt der Definition wird "wie es ist" gespeichert. Faule Bewertung wird verwendet, was bedeutet, dass Makros normalerweise nur dann erweitert werden, wenn ihre Erweiterungen tatsächlich erforderlich sind, z. B. wenn sie in den Befehlszeilen einer Regel verwendet werden. Ein erweitertes Beispiel:

PAKET  = PaketAUSFÜHRUNG  = ` Datum +"%Y.%m.%D" ` ARCHIV  = $ (PAKET)-$ (AUSFÜHRUNG) distieren: # Beachten Sie, dass Makros erst jetzt erweitert werden, damit Shell interpretiert wird: # tar -cf package -`Date +"%y.%m.%d" `.tar tar -cf $ (ARCHIV).Tar.

Die generische Syntax für überschreibende Makros in der Befehlszeile lautet:

machen MAKRO="Wert" [MAKRO="Wert" ...] ZIEL [ZIEL ...]

Makefiles können auf eine Reihe von vordefinierten Zugriffe zugreifen Interne Makros, mit ? und @ am häufigsten sein.

Ziel: Komponente1 Komponente2 # enthält die Komponenten, die Aufmerksamkeit benötigen (d. H. Sie sind jünger als das aktuelle Ziel). 	Echo $?  # bewertet den aktuellen Zielnamen unter denjenigen, die vom Dickdarm übrig sind. 	Echo $@

Eine etwas häufige Syntaxausdehnung ist die Verwendung von +=, ? =, und ! = anstelle des gleichen Zeichens. Es funktioniert auf BSD und GNU macht gleich.[46]

Suffixregeln

Suffix -Regeln haben "Ziele" mit Namen in der Form .FROM.TO und werden verwendet, um Aktionen basierend auf der Dateierweiterung zu starten. In den Befehlszeilen der Suffixregeln gibt POSIX an[47] dass das interne Makro $< bezieht sich auf die erste Voraussetzung und $@ bezieht sich auf das Ziel. In diesem Beispiel, in dem jede HTML -Datei in Text umwandelt, ist der Shell -Umleitungs -Token > ist Teil der Befehlszeile, während $< ist ein Makro, das sich auf die HTML -Datei bezieht:

Suffixe: .txt .html # Von .html zu .txt .html.txt: lynx -dump $ <> $@

Wenn Sie aus der Befehlszeile aufgerufen werden, wird das obige Beispiel erweitert.

$ make -n Datei.txtlynx -dump file.html> file.txt

Musterregeln

Suffix -Regeln können keine eigenen Voraussetzungen haben.[48] Wenn sie welche haben, werden sie als normale Dateien mit ungewöhnlichen Namen behandelt, nicht als Suffixregeln. GNU macht Unterstützung für Suffixregeln für die Kompatibilität mit alten Makefiles, fördert aber ansonsten die Nutzung von Musterregeln.[49]

Eine Musterregel sieht aus wie eine gewöhnliche Regel, außer dass ihr Ziel genau eine enthält % Zeichen innerhalb der Zeichenfolge. Das Ziel wird als Muster für die Dateinamen angesehen: die % kann jedem Substring von Null oder mehr Zeichen übereinstimmen,[50] während andere Charaktere nur selbst übereinstimmen. Die Voraussetzungen verwenden ebenfalls % Um zu zeigen, wie sich ihre Namen auf den Zielnamen beziehen.

Das Beispiel oben einer Suffix -Regel würde wie die folgende Musterregel aussehen:

# Von%.html bis%.txt %.txt :%.html  lynx -dump $ <> $@

Andere Elemente

Einzelne Zeile Kommentare werden mit dem begonnen Hash -Symbol (#).

Einige Richtlinien in Makefiles können enthalten Andere Makefiles.

Liniendauer ist mit einem Backslash angezeigt \ Charakter am Ende einer Linie.

   Ziel: Komponente \ Komponente Tab ↹Befehl ; \ Tab ↹Befehl | \ Tab ↹Piped-Command

Beispiel Makefiles

Das Makefile:

PAKET	 = PaketAUSFÜHRUNG	 = ` Datum "+%Y.%M%d%" ` Release_dir  = ..Release_file = $ (PAKET)-$ (AUSFÜHRUNG) # Beachten Sie, dass der variable Protokollname aus der Umgebung in stammt # POSIX -Shells. # # Ziel: Alle - Standardziel. Tut nichts. alle: 	Echo "Hallo $ (Logname), nichts zu tun zu tun " # Manchmal: echo "Hallo $ {logName}, nichts zu tun." 	Echo "Versuchen Sie, Hilfe zu machen" " # Ziel: Hilfe - Zeigen Sie Callable -Ziele an. Hilfe: Egrep "^# Ziel:" [Mm]AKEFILE# Ziel: Liste - Listenquelldateien aufführen: # Wird nicht funktionieren. Jeder Befehl befindet sich in einer separaten Shell 	CD src ls# Richtig, Fortsetzung derselben Hülle 	CD src; \ ls# Ziel: Dist - Machen Sie eine Veröffentlichung. distieren: tar -cf $ (Release_dir)/$ (Release_file) && \ gzip -9 $ (Release_dir)/$ (Release_file).Teer

Unten ist ein sehr einfaches Makefile, das standardmäßig (die "All" -Regel zuerst aufgeführt ist) eine Quelldatei mit dem Namen "HelloWorld.c" mit dem C -Compiler des Systems kompiliert und auch ein "sauberes" Ziel bereitstellt, um die generierten Dateien zu entfernen, wenn der Benutzer Wünsche, von vorne zu beginnen. Das $@ und $< sind zwei der sogenannten internen Makros (auch als automatische Variablen bezeichnet) und stehen für den Zielnamen bzw. "implizite" Quelle. Im folgenden Beispiel, $^ Erweitert auf eine ausgrenzte Liste der Voraussetzungen. Es gibt eine Reihe anderer interner Makros.[47][51] 

CFLAGs ? = -galle: Hallo Welt Hallo Welt: Hallo Welt.o # Befehle beginnen mit Tab -Leerzeichen, keine Leerzeichen 	$ (CC) $ (Ldflags) -Ö $@ $^helloWorld.o: Hallo Welt.c 	$ (CC) $ (CFLAGs) -c -o $@ $ <sauber: FRC 	$ (Rm) helloWorld helloWorld.o# Dieses Pseudo -Ziel verursacht alle Ziele, die von FRC abhängen # auch für den Fall, dass eine Datei mit dem Namen des Ziels vorhanden ist. # Dies funktioniert mit jeglicher Umsetzung unter der Annahme, dass # Es gibt keine Datei FRC im aktuellen Verzeichnis. FRC:

Viele Systeme sind mit vordefinierten Regeln und Makros ausgestattet, um gemeinsame Aufgaben wie die Kompilierung basierend auf dem Dateisuffix anzugeben. Auf diese Weise können Benutzer die tatsächlichen (oft nicht portablen) Anweisungen zum Generieren des Ziels aus der Quelle (en) weglassen. Bei einem solchen System könnte das obige Makefile wie folgt geändert werden:

alle: Hallo Welt Hallo Welt: Hallo Welt.o 	$ (CC) $ (CFLAGs) $ (Ldflags) -Ö $@ $^sauber: FRC 	$ (Rm) helloWorld helloWorld.o# Dies ist eine explizite Suffixregel. Es kann auf Systemen weggelassen werden # Das verarbeitet einfache Regeln wie diese automatisch. .c.o: 	$ (CC) $ (CFLAGs) -c $ <FRC: Suffixe: .c


Diese "helloWorld.o" hängt von "helloWorld.c" ab, wird jetzt automatisch von Make behandelt. In einem so einfachen Beispiel, wie das hier veranschaulicht, ist dies kaum wichtig, aber die tatsächliche Kraft der Suffixregeln wird offensichtlich, wenn die Anzahl der Quelldateien in einem Softwareprojekt zu wachsen beginnt. Man muss nur eine Regel für den Verknüpfungsschritt schreiben und die Objektdateien als Voraussetzungen deklarieren. Make wird dann implizit bestimmen, wie Sie alle Objektdateien erstellen und nach Änderungen in allen Quelldateien suchen.

Einfache Suffix -Regeln funktionieren gut, solange die Quelldateien nicht voneinander und von anderen Dateien wie Header -Dateien abhängen. Eine weitere Route zur Vereinfachung des Erstellungsprozesses besteht darin, sogenannte Musteranpassungsregeln zu verwenden, die mit der Zusammenarbeit mithilfe der Abhängigkeitserzeugung kombiniert werden können. Als letztes Beispiel, das den GCC -Compiler und GNU erfordern, finden Sie hier ein generisches Makefile, das alle C -Dateien in einem Ordner mit den entsprechenden Objektdateien kompiliert und dann mit der endgültigen ausführbaren Datei verknüpft wird. Vor der Kompilierung werden Abhängigkeiten im makefile-freundlichen Format in eine versteckte Datei gesammelt. Tragbare Programme sollten nachstehend konstruiert werden.

# Generische Gnumakefile # Nur ein Ausschnitt zum Ausführen unter anderen (1) Befehlen # Das wird diese Zeilen nicht verstehen ifneq (,) Dies Makefile erfordert GNU Machen. Endif PROGRAMM = FooC_files : = $ (Wildcard *.C) Objs : = $ (patsubst%.c,%.o, $ (C_files)) CC = CCCFLAGs = -Wall -pedantischLdflags = Ldlibs = -lmalle: $ (PROGRAMM) $ (Programm): .abhängen $ (Objs) 	$ (CC) $ (CFLAGs) $ (Objs) $ (Ldflags) -Ö $ (PROGRAMM) $ (Ldlibs) abhängen: .abhängen .abhängen: CMD = GCC -Mm -Mf abhängen $ (var); Katze abhängen >>.abhängen;.abhängen: @Echo "Abhängigkeiten generieren ..." @$ (foreach var, $ (C_files), $ (CMD)) @rm -f abhängig-Inklude. Abhängig # Dies sind die Musteranpassungsregeln. Zusätzlich zur Automatik # hier verwendete Variablen, die Variable $*, die übereinstimmt, für was% steht # kann in besonderen Fällen nützlich sein. %.Ö:%.c 	$ (CC) $ (CFLAGs) -c $ <-o $@ %:%.o 	$ (CC) $ (CFLAGs) -Ö $@ $ <sauber: RM -f. Abhängig $ (Objs) .Phony: sauber abhängen

Siehe auch

Verweise

  1. ^ a b Thompson, T. J. (November 1980). "Designer's Workbench: Bereitstellung einer Produktionsumgebung". Glockensystem Technisches Journal. 59 (9): 1811–1825. doi:10.1002/j.1538-7305.1980.tb03063.x. S2CID 27213583. Bei der allgemeinen Wartung von DWB haben wir das Quellcode -Steuerungssystem verwendet und das vom PWB/UNIX* interaktive Betriebssystem bereitgestellte Dienstprogramme erstellt.
  2. ^ "V7/usr/src/cmd/make/ident.c". tuhs.org. 1. September 2013. archiviert von das Original am 1. September 2013. Abgerufen 18. März 2018.
  3. ^ Feldman, S. I. (April 1979). "Make-ein Programm zur Wartung von Computerprogrammen". Software: Übung und Erfahrung. 9 (4): 255–265. Citeseerx 10.1.1.39.7058. doi:10.1002/spe.4380090402. S2CID 33059412.
  4. ^ Matthew Doar (2005). Praktische Entwicklungsumgebungen. O'Reilly Media. p. 94. ISBN 978-0-596-00796-6.
  5. ^ "Google -Gruppen". Arquivo.pt. Archiviert vom Original am 22. Januar 2011. Abgerufen 18. März 2018.{{}}: CS1 Wartung: Bot: Original -URL -Status unbekannt (Link)
  6. ^ "OpenSolaris bei zwei (Jim Grisanzio)". 12. Dezember 2013. archiviert von das Original am 12. Dezember 2013. Abgerufen 18. März 2018.
  7. ^ Grisanzio, Jim. Die OpenSolaris -Geschichte.
  8. ^ a b c "Entwicklung/GBUILD - Das Dokumentstiftung Wiki". Wiki.DocumentFoundation.org. Abgerufen 18. März 2018.
  9. ^ a b "Apache OpenOffice Building Guide - Apache OpenOffice Wiki". Wiki.openoffice.org. Abgerufen 18. März 2018.
  10. ^ FreeBSD 2.0.5 Erstellen Sie Quellcode, 1993
  11. ^ a b "Bmake (1)".
  12. ^ https://manpages.debian.org/jessie/freebsd-buildutils/fmake.1[Bare URL -Klartextdatei]
  13. ^ "machen". NETBSD -Handbuchseiten. Abgerufen 9. Juli 2020.
  14. ^ "Make (1) - OpenBSD -Handbuchseiten". Man.openbsd.org. Abgerufen 18. März 2018.
  15. ^ "machen". Freebsd. Abgerufen 9. Juli 2020. Makefile -Einschluss, bedingte Strukturen und für Schleifen, die an die C -Programmiersprache erinnern, sind in Make bereitgestellt.
  16. ^ Arnold Robbins (2005), Unix auf den Punkt gebracht, vierte Ausgabe, O'Reilly
  17. ^ "8. Funktionen zur Transformation von Text", Gnu machen, Free Software Foundation, 2013
  18. ^ "8.5 Die Foreach -Funktion", Gnu machen, Free Software Foundation, 2013
  19. ^ "GCC 3.4 Release -Serienwechsel, neue Funktionen und Fixes". Kostenlose Software -Stiftung. 2006.
  20. ^ Javier Martinez Canillas (26. Dezember 2012). "KBUILD: Das Linux -Kernel -Build -System". Linux Journal.
  21. ^ Greg Kroah-Hartman (2006), Linux -Kernel auf den Punkt gebracht, O'Reilly
  22. ^ "Anweisungen erstellen".
  23. ^ Rocky Bernstein. "Remake - GNU Make mit umfassender Verfolgung und Debugger".
  24. ^ Glenn Fowler (4. Januar 2012). "Nmake -Übersicht". Forschung für Informations- und Softwaresysteme, AT & T Labs Research. Archiviert von das Original am 2. September 2015. Abgerufen 26. Mai, 2014.
  25. ^ "NMake Referenz Visual Studio 2015". Microsoft. 2015.
  26. ^ "Makefile -Vorverarbeitungsrichtlinien". 2014.
  27. ^ "Makefile -Vorverarbeitungsbetreiber". Microsoft. 2014.
  28. ^ "Suchpfade in Regeln suchen". Microsoft. 2014.
  29. ^ "MACHEN". CodeGear (TM). 2008.
  30. ^ "JOM - QT Wiki". QT -Projekt. 2021.
  31. ^ McIlroy, M. D. (1987). A Research Unix Reader: Annotierte Auszüge aus dem Programmierhandbuch, 1971–1986 (PDF) (Technischer Bericht). Bell Labs. CSTR 139.
  32. ^ Hume, Andrew G.; Flandrena, Bob (2002). "Dateien in Plan 9 mit MK verwalten". Programmierhandbuch von Plan 9. AT & T Bell Laboratories. Archiviert Aus dem Original am 11. Juli 2015.
  33. ^ "Google/Kati: Ein experimenteller GNU macht Klon". GitHub. 30. November 2020.
  34. ^ Mölder, Felix; Jablonski, Kim Philipp; Letcher, Brice; Hall, Michael B.; Tomkins-Tinch, Christopher H.; Sochat, Vanessa; Forster, Jan; Lee, Soohyun; Twardziok, Sven O.; Kanitz, Alexander; Wilm, Andreas (2021-04-19). "Nachhaltige Datenanalyse mit Snakemake". F1000Research. 10: 33. doi:10.12688/f1000Research.29032.2. ISSN 2046-1402. PMC 8114187. PMID 34035898.
  35. ^ "Gnu 'mach' '". Kostenlose Software -Stiftung.
  36. ^ "Makepp".
  37. ^ "Kostenlose BSD machen".
  38. ^ So sortieren Sie die Befehlsdateiausgabe von Linux LS Archiviert 13. September 2016 bei der Wayback -Maschine
  39. ^ Ein Überblick über DSLs Archiviert 23. Oktober 2007 bei der Wayback -Maschine, 2007/02/27, Phoenix Wiki
  40. ^ Re: Choreografie und Ruhe Archiviert 12. September 2016 bei der Wayback -Maschine, aus Christopher B Ferris am 2002-08-09
  41. ^ Ziel Junior Makefiles Archiviert 7. Januar 2010 bei der Wayback -Maschine, Andrew W. Fitzgibbon und William A. Hoffman
  42. ^ 3.1 Was Makefiles enthalten, Gnu machen, Kostenlose Software -Stiftung
  43. ^ "Voraussetzungstypen (GNU make)". Gnu.org. GNU -Projekt. Abgerufen 15. Dezember 2020.
  44. ^ a b "Kapitel 15. Tools: Make: Automatisierung Ihrer Rezepte", Die Kunst der Unix -Programmierung, Eric S. Raymond 2003
  45. ^ machen- Shell and Utilities Referenz, Die einzelne Unix -Spezifikation, Version 4 von Die offene Gruppe
  46. ^ (1) machen- -Freebsd Allgemeine Befehle Handbuch
  47. ^ a b "machen". www.opengroup.org. Abgerufen 18. März 2018.
  48. ^ "GNU MACHE MACHE: Suffix Regeln". Kostenlose Software -Stiftung.
  49. ^ "GNU MACHE MACHE: Musterregeln". Kostenlose Software -Stiftung.
  50. ^ Siehe Sektion Musteranpassungsregeln In der Seite SunPro Man Archiviert 29. Mai 2014 bei der Wayback -Maschine
  51. ^ Automatische Variablen Archiviert 25. April 2016 bei der Wayback -Maschine Gnu "make"

Externe Links