From 818b8eec46b11b36b5235ecbce540557afec4687 Mon Sep 17 00:00:00 2001 From: Boris Verkhovskiy Date: Thu, 4 Apr 2024 00:27:01 -0700 Subject: Convert \r\n to \n --- de-de/make-de.html.markdown | 526 ++++++++++++++++++++++---------------------- 1 file changed, 263 insertions(+), 263 deletions(-) (limited to 'de-de/make-de.html.markdown') diff --git a/de-de/make-de.html.markdown b/de-de/make-de.html.markdown index 1bae332c..3674f2f5 100644 --- a/de-de/make-de.html.markdown +++ b/de-de/make-de.html.markdown @@ -1,263 +1,263 @@ ---- -category: tool -tool: make -contributors: - - ["Robert Steed", "https://github.com/robochat"] - - ["Stephan Fuhrmann", "https://github.com/sfuhrm"] -translators: - - ["Martin Schimandl", "https://github.com/Git-Jiro"] -filename: Makefile-de -lang: de-de ---- - -Eine Makefile definiert einen Graphen von Regeln um ein Ziel (oder Ziele) -zu erzeugen. Es dient dazu, die geringste Menge an Arbeit zu verrichten um -ein Ziel in Einklang mit dem Quellcode zu bringen. Make wurde berühmterweise -von Stuart Feldman 1976 übers Wochenende geschrieben. Make ist noch immer -sehr verbreitet (vorallem im Unix Umfeld) obwohl es bereits sehr viel -Konkurrenz und Kritik zu Make gibt. - -Es gibt eine Vielzahl an Varianten von Make, dieser Artikel beschäftigt sich -mit der Version GNU Make. Diese Version ist Standard auf Linux. - -```make - -# Kommentare können so geschrieben werden. - -# Dateien sollten Makefile heißen, denn dann können sie als `make ` -# aufgerufen werden. Ansonsten muss `make -f "dateiname" ` verwendet -# werden. - -# Warnung - Es sollten nur TABULATOREN zur Einrückung im Makefile verwendet -# werden. Niemals Leerzeichen! - -#----------------------------------------------------------------------- -# Grundlagen -#----------------------------------------------------------------------- - -# Eine Regel - Diese Regel wird nur abgearbeitet wenn die Datei file0.txt -# nicht existiert. -file0.txt: - echo "foo" > file0.txt - # Selbst Kommentare in der 'Rezept' Sektion werden an die Shell - # weitergegeben. Versuche `make file0.txt` oder einfach `make` - # die erste Regel ist die Standard-Regel. - - -# Diese Regel wird nur abgearbeitet, wenn file0.txt aktueller als file1.txt ist. -file1.txt: file0.txt - cat file0.txt > file1.txt - # Verwende die selben Quoting-Regeln wie die Shell - @cat file0.txt >> file1.txt - # @ unterdrückt die Ausgabe des Befehls an stdout. - -@echo 'hello' - # - bedeutet, dass Make die Abarbeitung fortsetzt auch wenn Fehler - # passieren. - # Versuche `make file1.txt` auf der Kommandozeile. - -# Eine Regel kann mehrere Ziele und mehrere Voraussetzungen haben. -file2.txt file3.txt: file0.txt file1.txt - touch file2.txt - touch file3.txt - -# Make wird sich beschweren, wenn es mehrere Rezepte für die gleiche Regel gibt. -# Leere Rezepte zählen nicht und können dazu verwendet werden weitere -# Voraussetzungen hinzuzufügen. - -#----------------------------------------------------------------------- -# Phony-Ziele -#----------------------------------------------------------------------- - -# Ein Phony-Ziel ist ein Ziel, das keine Datei ist. -# Es wird nie aktuell sein, daher wird Make immer versuchen, es abzuarbeiten -all: maker process - -# Es ist erlaubt Dinge ausserhalb der Reihenfolge zu deklarieren. -maker: - touch ex0.txt ex1.txt - -# Um das Fehlschlagen von Phony-Regeln zu vermeiden wenn eine echte Datei den -# selben namen wie ein Phony-Ziel hat: -.PHONY: all maker process -# Das ist ein spezielles Ziel. Es gibt noch ein paar mehr davon. - -# Eine Regel mit einem Phony-Ziel als Voraussetzung wird immer abgearbeitet -ex0.txt ex1.txt: maker - -# Häufige Phony-Ziele sind: all make clean install ... - -#----------------------------------------------------------------------- -# Automatische Variablen & Wildcards -#----------------------------------------------------------------------- - -process: file*.txt # Eine Wildcard um Dateinamen zu vergleichen - @echo $^ # $^ ist eine Variable die eine Liste aller - # Voraussetzungen enthält. - @echo $@ # Namen des Ziels ausgeben. - #(Bei mehreren Ziel-Regeln enthält $@ den Verursacher der Abarbeitung - #der Regel.) - @echo $< # Die erste Voraussetzung aus der Liste - @echo $? # Nur die Voraussetzungen, die nicht aktuell sind. - @echo $+ # Alle Voraussetzungen inklusive Duplikate (nicht wie Üblich) - #@echo $| # Alle 'order only' Voraussetzungen - -# Selbst wenn wir die Voraussetzungen der Regel aufteilen, $^ wird sie finden. -process: ex1.txt file0.txt -# ex1.txt wird gefunden werden, aber file0.txt wird dedupliziert. - -#----------------------------------------------------------------------- -# Muster -#----------------------------------------------------------------------- - -# Mit Mustern kann man make beibringen wie Dateien in andere Dateien -# umgewandelt werden. - -%.png: %.svg - inkscape --export-png $^ - -# Muster-Vergleichs-Regeln werden nur abgearbeitet, wenn make entscheidet das -# Ziel zu erzeugen - -# Verzeichnis-Pfade werden normalerweise bei Muster-Vergleichs-Regeln ignoriert. -# Aber make wird versuchen die am besten passende Regel zu verwenden. -small/%.png: %.svg - inkscape --export-png --export-dpi 30 $^ - -# Make wird die letzte Version einer Muster-Vergleichs-Regel verwenden, die es -# findet. -%.png: %.svg - @echo this rule is chosen - -# Allerdings wird make die erste Muster-Vergleicher-Regel verwenden, die das -# Ziel erzeugen kann. -%.png: %.ps - @echo this rule is not chosen if *.svg and *.ps are both present - -# Make hat bereits ein paar eingebaute Muster-Vergleichs-Regelen. Zum Beispiel -# weiß Make wie man aus *.c Dateien *.o Dateien erzeugt. - -# Ältere Versionen von Make verwenden möglicherweise Suffix-Regeln anstatt -# Muster-Vergleichs-Regeln. -.png.ps: - @echo this rule is similar to a pattern rule. - -# Aktivieren der Suffix-Regel -.SUFFIXES: .png - -#----------------------------------------------------------------------- -# Variablen -#----------------------------------------------------------------------- -# auch Makros genannt. - -# Variablen sind im Grunde genommen Zeichenketten-Typen. - -name = Ted -name2="Sarah" - -echo: - @echo $(name) - @echo ${name2} - @echo $name # Das funktioniert nicht, wird als $(n)ame behandelt. - @echo $(name3) # Unbekannte Variablen werden als leere Zeichenketten behandelt. - -# Es git 4 Stellen um Variablen zu setzen. -# In Reihenfolge der Priorität von höchster zu niedrigster: -# 1: Befehls-Zeilen Argumente -# 2: Makefile -# 3: Shell Umbebungs-Variablen - Make importiert diese automatisch. -# 3: MAke hat einige vordefinierte Variablen. - -name4 ?= Jean -# Setze die Variable nur wenn es eine gleichnamige Umgebungs-Variable noch -# nicht gibt. - -override name5 = David -# Verhindert, dass Kommando-Zeilen Argumente diese Variable ändern können. - -name4 +=grey -# Werte an eine Variable anhängen (inkludiert Leerzeichen). - -# Muster-Spezifische Variablen Werte (GNU Erweiterung). -echo: name2 = Sara # Wahr innerhalb der passenden Regel und auch innerhalb - # rekursiver Voraussetzungen (ausser wenn es den Graphen zerstören - # kann, wenn es zu kompilizert wird!) - -# Ein paar Variablen, die von Make automatisch definiert werden. -echo_inbuilt: - echo $(CC) - echo ${CXX} - echo $(FC) - echo ${CFLAGS} - echo $(CPPFLAGS) - echo ${CXXFLAGS} - echo $(LDFLAGS) - echo ${LDLIBS} - -#----------------------------------------------------------------------- -# Variablen 2 -#----------------------------------------------------------------------- - -# Der erste Typ von Variablen wird bei jeder Verwendung ausgewertet. -# Das kann aufwendig sein, daher exisitert ein zweiter Typ von Variablen. -# Diese werden nur einmal ausgewertet. (Das ist eine GNU make Erweiterung) - -var := hello -var2 ::= $(var) hello -#:= und ::= sind äquivalent. - -# Diese Variablen werden prozedural ausgwertet (in der Reihenfolge in der sie -# auftauchen), die stehen daher im wiederspruch zum Rest der Sprache! - -# Das funktioniert nicht -var3 ::= $(var4) and good luck -var4 ::= good night - -#----------------------------------------------------------------------- -# Funktionen -#----------------------------------------------------------------------- - -# Make verfügt über eine Vielzahl von Funktionen. - -sourcefiles = $(wildcard *.c */*.c) -objectfiles = $(patsubst %.c,%.o,$(sourcefiles)) - -# Das Format ist $(func arg0,arg1,arg2...) - -# Ein paar Beispiele -ls: * src/* - @echo $(filter %.txt, $^) - @echo $(notdir $^) - @echo $(join $(dir $^),$(notdir $^)) - -#----------------------------------------------------------------------- -# Direktiven -#----------------------------------------------------------------------- - -# Inkludiere andere Makefile, sehr praktisch für platformspezifischen Code -include foo.mk - -sport = tennis -# Konditionale kompiliereung -report: -ifeq ($(sport),tennis) - @echo 'game, set, match' -else - @echo "They think it's all over; it is now" -endif - -# Es gibt auch ifneq, ifdef, ifndef - -foo = true - -ifdef $(foo) -bar = 'hello' -endif -``` - - -### Mehr Resourcen - -+ [gnu make documentation](https://www.gnu.org/software/make/manual/) -+ [software carpentry tutorial](http://swcarpentry.github.io/make-novice/) -+ learn C the hard way [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html) - +--- +category: tool +tool: make +contributors: + - ["Robert Steed", "https://github.com/robochat"] + - ["Stephan Fuhrmann", "https://github.com/sfuhrm"] +translators: + - ["Martin Schimandl", "https://github.com/Git-Jiro"] +filename: Makefile-de +lang: de-de +--- + +Eine Makefile definiert einen Graphen von Regeln um ein Ziel (oder Ziele) +zu erzeugen. Es dient dazu, die geringste Menge an Arbeit zu verrichten um +ein Ziel in Einklang mit dem Quellcode zu bringen. Make wurde berühmterweise +von Stuart Feldman 1976 übers Wochenende geschrieben. Make ist noch immer +sehr verbreitet (vorallem im Unix Umfeld) obwohl es bereits sehr viel +Konkurrenz und Kritik zu Make gibt. + +Es gibt eine Vielzahl an Varianten von Make, dieser Artikel beschäftigt sich +mit der Version GNU Make. Diese Version ist Standard auf Linux. + +```make + +# Kommentare können so geschrieben werden. + +# Dateien sollten Makefile heißen, denn dann können sie als `make ` +# aufgerufen werden. Ansonsten muss `make -f "dateiname" ` verwendet +# werden. + +# Warnung - Es sollten nur TABULATOREN zur Einrückung im Makefile verwendet +# werden. Niemals Leerzeichen! + +#----------------------------------------------------------------------- +# Grundlagen +#----------------------------------------------------------------------- + +# Eine Regel - Diese Regel wird nur abgearbeitet wenn die Datei file0.txt +# nicht existiert. +file0.txt: + echo "foo" > file0.txt + # Selbst Kommentare in der 'Rezept' Sektion werden an die Shell + # weitergegeben. Versuche `make file0.txt` oder einfach `make` + # die erste Regel ist die Standard-Regel. + + +# Diese Regel wird nur abgearbeitet, wenn file0.txt aktueller als file1.txt ist. +file1.txt: file0.txt + cat file0.txt > file1.txt + # Verwende die selben Quoting-Regeln wie die Shell + @cat file0.txt >> file1.txt + # @ unterdrückt die Ausgabe des Befehls an stdout. + -@echo 'hello' + # - bedeutet, dass Make die Abarbeitung fortsetzt auch wenn Fehler + # passieren. + # Versuche `make file1.txt` auf der Kommandozeile. + +# Eine Regel kann mehrere Ziele und mehrere Voraussetzungen haben. +file2.txt file3.txt: file0.txt file1.txt + touch file2.txt + touch file3.txt + +# Make wird sich beschweren, wenn es mehrere Rezepte für die gleiche Regel gibt. +# Leere Rezepte zählen nicht und können dazu verwendet werden weitere +# Voraussetzungen hinzuzufügen. + +#----------------------------------------------------------------------- +# Phony-Ziele +#----------------------------------------------------------------------- + +# Ein Phony-Ziel ist ein Ziel, das keine Datei ist. +# Es wird nie aktuell sein, daher wird Make immer versuchen, es abzuarbeiten +all: maker process + +# Es ist erlaubt Dinge ausserhalb der Reihenfolge zu deklarieren. +maker: + touch ex0.txt ex1.txt + +# Um das Fehlschlagen von Phony-Regeln zu vermeiden wenn eine echte Datei den +# selben namen wie ein Phony-Ziel hat: +.PHONY: all maker process +# Das ist ein spezielles Ziel. Es gibt noch ein paar mehr davon. + +# Eine Regel mit einem Phony-Ziel als Voraussetzung wird immer abgearbeitet +ex0.txt ex1.txt: maker + +# Häufige Phony-Ziele sind: all make clean install ... + +#----------------------------------------------------------------------- +# Automatische Variablen & Wildcards +#----------------------------------------------------------------------- + +process: file*.txt # Eine Wildcard um Dateinamen zu vergleichen + @echo $^ # $^ ist eine Variable die eine Liste aller + # Voraussetzungen enthält. + @echo $@ # Namen des Ziels ausgeben. + #(Bei mehreren Ziel-Regeln enthält $@ den Verursacher der Abarbeitung + #der Regel.) + @echo $< # Die erste Voraussetzung aus der Liste + @echo $? # Nur die Voraussetzungen, die nicht aktuell sind. + @echo $+ # Alle Voraussetzungen inklusive Duplikate (nicht wie Üblich) + #@echo $| # Alle 'order only' Voraussetzungen + +# Selbst wenn wir die Voraussetzungen der Regel aufteilen, $^ wird sie finden. +process: ex1.txt file0.txt +# ex1.txt wird gefunden werden, aber file0.txt wird dedupliziert. + +#----------------------------------------------------------------------- +# Muster +#----------------------------------------------------------------------- + +# Mit Mustern kann man make beibringen wie Dateien in andere Dateien +# umgewandelt werden. + +%.png: %.svg + inkscape --export-png $^ + +# Muster-Vergleichs-Regeln werden nur abgearbeitet, wenn make entscheidet das +# Ziel zu erzeugen + +# Verzeichnis-Pfade werden normalerweise bei Muster-Vergleichs-Regeln ignoriert. +# Aber make wird versuchen die am besten passende Regel zu verwenden. +small/%.png: %.svg + inkscape --export-png --export-dpi 30 $^ + +# Make wird die letzte Version einer Muster-Vergleichs-Regel verwenden, die es +# findet. +%.png: %.svg + @echo this rule is chosen + +# Allerdings wird make die erste Muster-Vergleicher-Regel verwenden, die das +# Ziel erzeugen kann. +%.png: %.ps + @echo this rule is not chosen if *.svg and *.ps are both present + +# Make hat bereits ein paar eingebaute Muster-Vergleichs-Regelen. Zum Beispiel +# weiß Make wie man aus *.c Dateien *.o Dateien erzeugt. + +# Ältere Versionen von Make verwenden möglicherweise Suffix-Regeln anstatt +# Muster-Vergleichs-Regeln. +.png.ps: + @echo this rule is similar to a pattern rule. + +# Aktivieren der Suffix-Regel +.SUFFIXES: .png + +#----------------------------------------------------------------------- +# Variablen +#----------------------------------------------------------------------- +# auch Makros genannt. + +# Variablen sind im Grunde genommen Zeichenketten-Typen. + +name = Ted +name2="Sarah" + +echo: + @echo $(name) + @echo ${name2} + @echo $name # Das funktioniert nicht, wird als $(n)ame behandelt. + @echo $(name3) # Unbekannte Variablen werden als leere Zeichenketten behandelt. + +# Es git 4 Stellen um Variablen zu setzen. +# In Reihenfolge der Priorität von höchster zu niedrigster: +# 1: Befehls-Zeilen Argumente +# 2: Makefile +# 3: Shell Umbebungs-Variablen - Make importiert diese automatisch. +# 3: MAke hat einige vordefinierte Variablen. + +name4 ?= Jean +# Setze die Variable nur wenn es eine gleichnamige Umgebungs-Variable noch +# nicht gibt. + +override name5 = David +# Verhindert, dass Kommando-Zeilen Argumente diese Variable ändern können. + +name4 +=grey +# Werte an eine Variable anhängen (inkludiert Leerzeichen). + +# Muster-Spezifische Variablen Werte (GNU Erweiterung). +echo: name2 = Sara # Wahr innerhalb der passenden Regel und auch innerhalb + # rekursiver Voraussetzungen (ausser wenn es den Graphen zerstören + # kann, wenn es zu kompilizert wird!) + +# Ein paar Variablen, die von Make automatisch definiert werden. +echo_inbuilt: + echo $(CC) + echo ${CXX} + echo $(FC) + echo ${CFLAGS} + echo $(CPPFLAGS) + echo ${CXXFLAGS} + echo $(LDFLAGS) + echo ${LDLIBS} + +#----------------------------------------------------------------------- +# Variablen 2 +#----------------------------------------------------------------------- + +# Der erste Typ von Variablen wird bei jeder Verwendung ausgewertet. +# Das kann aufwendig sein, daher exisitert ein zweiter Typ von Variablen. +# Diese werden nur einmal ausgewertet. (Das ist eine GNU make Erweiterung) + +var := hello +var2 ::= $(var) hello +#:= und ::= sind äquivalent. + +# Diese Variablen werden prozedural ausgwertet (in der Reihenfolge in der sie +# auftauchen), die stehen daher im wiederspruch zum Rest der Sprache! + +# Das funktioniert nicht +var3 ::= $(var4) and good luck +var4 ::= good night + +#----------------------------------------------------------------------- +# Funktionen +#----------------------------------------------------------------------- + +# Make verfügt über eine Vielzahl von Funktionen. + +sourcefiles = $(wildcard *.c */*.c) +objectfiles = $(patsubst %.c,%.o,$(sourcefiles)) + +# Das Format ist $(func arg0,arg1,arg2...) + +# Ein paar Beispiele +ls: * src/* + @echo $(filter %.txt, $^) + @echo $(notdir $^) + @echo $(join $(dir $^),$(notdir $^)) + +#----------------------------------------------------------------------- +# Direktiven +#----------------------------------------------------------------------- + +# Inkludiere andere Makefile, sehr praktisch für platformspezifischen Code +include foo.mk + +sport = tennis +# Konditionale kompiliereung +report: +ifeq ($(sport),tennis) + @echo 'game, set, match' +else + @echo "They think it's all over; it is now" +endif + +# Es gibt auch ifneq, ifdef, ifndef + +foo = true + +ifdef $(foo) +bar = 'hello' +endif +``` + + +### Mehr Resourcen + ++ [gnu make documentation](https://www.gnu.org/software/make/manual/) ++ [software carpentry tutorial](http://swcarpentry.github.io/make-novice/) ++ learn C the hard way [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html) + -- cgit v1.2.3