+#: doc/guix.texi:7721
+#, no-wrap
+msgid "build phases, for packages"
+msgstr "Erstellungsphasen, bei Paketen"
+
+#. type: Plain text
+#: doc/guix.texi:7727
+msgid "Almost all package build systems implement a notion @dfn{build phases}: a sequence of actions that the build system executes, when you build the package, leading to the installed byproducts in the store. A notable exception is the ``bare-bones'' @code{trivial-build-system} (@pxref{Build Systems})."
+msgstr "Fast alle Erstellungssysteme für Pakete implementieren ein Konzept von @dfn{Erstellungsphasen}: einer Abfolge von Aktionen, die vom Erstellungssystem ausgeführt werden, wenn Sie das Paket erstellen. Dabei fallen in den Store installierte Nebenerzeugnisse an. Eine Ausnahme ist der Erwähnung wert: das magere @code{trivial-build-system} (siehe @ref{Build Systems})."
+
+#. type: Plain text
+#: doc/guix.texi:7741
+msgid "As discussed in the previous section, those build systems provide a standard list of phases. For @code{gnu-build-system}, the standard phases include an @code{unpack} phase to unpack the source code tarball, a @command{configure} phase to run @code{./configure}, a @code{build} phase to run @command{make}, and (among others) an @code{install} phase to run @command{make install}; @pxref{Build Systems}, for a more detailed view of these phases. Likewise, @code{cmake-build-system} inherits these phases, but its @code{configure} phase runs @command{cmake} instead of @command{./configure}. Other build systems, such as @code{python-build-system}, have a wholly different list of standard phases. All this code runs on the @dfn{build side}: it is evaluated when you actually build the package, in a dedicated build process spawned by the build daemon (@pxref{Invoking guix-daemon})."
+msgstr "Wie im letzten Abschnitt erläutert, stellen diese Erstellungssysteme eine standardisierte Liste von Phasen zur Verfügung. Für @code{gnu-build-system} gehören zu den Standardphasen eine @code{unpack}-Phase, wo der Quellcode-Tarball entpackt wird, eine @command{configure}-Phase, wo @code{./configure} ausgeführt wird, eine @code{build}-Phase, um @command{make} auszuführen, und (unter anderem) eine @code{install}-Phase, um @command{make install} auszuführen. Siehe @ref{Build Systems} für eine Detailansicht dieser Phasen. @code{cmake-build-system} erbt diese Phasen, aber seine @code{configure}-Phase führt @command{cmake} statt @command{./configure} aus. Andere Erstellungssysteme wie z.B.@: @code{python-build-system} haben eine völlig andere Liste von Standardphasen. Dieser gesamte Code läuft @dfn{erstellungsseitig}: Er wird dann ausgewertet, wenn Sie das Paket wirklich erstellen, in einem eigenen Erstellungprozess nur dafür, den der Erstellungs-Daemon erzeugt (siehe @ref{Invoking guix-daemon})."
+
+#. type: Plain text
+#: doc/guix.texi:7748
+msgid "Build phases are represented as association lists or ``alists'' (@pxref{Association Lists,,, guile, GNU Guile Reference Manual}) where each key is a symbol for the name of the phase and the associated value is a procedure that accepts an arbitrary number of arguments. By convention, those procedures receive information about the build in the form of @dfn{keyword parameters}, which they can use or ignore."
+msgstr "Erstellungsphasen werden durch assoziative Listen (kurz „Alists“) repräsentiert (siehe @ref{Association Lists,,, guile, Referenzhandbuch zu GNU Guile}) wo jeder Schlüssel ein Symbol für den Namen der Phase ist und der assoziierte Wert eine Prozedur ist, die eine beliebige Anzahl von Argumenten nimmt. Nach Konvention empfangen diese Prozeduren dadurch Informationen über die Erstellung in Form von @dfn{Schlüsselwort-Parametern}, die darin benutzt oder ignoriert werden können."
+
+#. type: Plain text
+#: doc/guix.texi:7754
+msgid "For example, here is how @code{(guix build gnu-build-system)} defines @code{%standard-phases}, the variable holding its alist of build phases@footnote{We present a simplified view of those build phases, but do take a look at @code{(guix build gnu-build-system)} to see all the details!}:"
+msgstr "Zum Beispiel werden die @code{%standard-phases}, das ist die Variable mit der Alist der Erstellungsphasen, in @code{(guix build gnu-build-system)} so definiert@footnote{Wir stellen hier nur eine vereinfachte Sicht auf diese Erstellungsphasen vor. Wenn Sie alle Details wollen, schauen Sie sich @code{(guix build gnu-build-system)} an!}:"
+
+#. type: lisp
+#: doc/guix.texi:7757
+#, no-wrap
+msgid ""
+";; The build phases of 'gnu-build-system'.\n"
+"\n"
+msgstr ""
+";; Die Erstellungsphasen von 'gnu-build-system'.\n"
+"\n"
+
+#. type: lisp
+#: doc/guix.texi:7761
+#, no-wrap
+msgid ""
+"(define* (unpack #:key source #:allow-other-keys)\n"
+" ;; Extract the source tarball.\n"
+" (invoke \"tar\" \"xvf\" source))\n"
+"\n"
+msgstr ""
+"(define* (unpack #:key source #:allow-other-keys)\n"
+" ;; Quelltarball extrahieren.\n"
+" (invoke \"tar\" \"xvf\" source))\n"
+"\n"
+
+#. type: lisp
+#: doc/guix.texi:7767
+#, no-wrap
+msgid ""
+"(define* (configure #:key outputs #:allow-other-keys)\n"
+" ;; Run the 'configure' script. Install to output \"out\".\n"
+" (let ((out (assoc-ref outputs \"out\")))\n"
+" (invoke \"./configure\"\n"
+" (string-append \"--prefix=\" out))))\n"
+"\n"
+msgstr ""
+"(define* (configure #:key outputs #:allow-other-keys)\n"
+" ;; 'configure'-Skript ausführen. In Ausgabe \"out\" installieren.\n"
+" (let ((out (assoc-ref outputs \"out\")))\n"
+" (invoke \"./configure\"\n"
+" (string-append \"--prefix=\" out))))\n"
+"\n"
+
+#. type: lisp
+#: doc/guix.texi:7771
+#, no-wrap
+msgid ""
+"(define* (build #:allow-other-keys)\n"
+" ;; Compile.\n"
+" (invoke \"make\"))\n"
+"\n"
+msgstr ""
+"(define* (build #:allow-other-keys)\n"
+" ;; Kompilieren.\n"
+" (invoke \"make\"))\n"
+"\n"
+
+#. type: lisp
+#: doc/guix.texi:7778
+#, no-wrap
+msgid ""
+"(define* (check #:key (test-target \"check\") (tests? #true)\n"
+" #:allow-other-keys)\n"
+" ;; Run the test suite.\n"
+" (if tests?\n"
+" (invoke \"make\" test-target)\n"
+" (display \"test suite not run\\n\")))\n"
+"\n"
+msgstr ""
+"(define* (check #:key (test-target \"check\") (tests? #true)\n"
+" #:allow-other-keys)\n"
+" ;; Testkatalog ausführen.\n"
+" (if tests?\n"
+" (invoke \"make\" test-target)\n"
+" (display \"test suite not run\\n\")))\n"
+"\n"
+
+#. type: lisp
+#: doc/guix.texi:7782
+#, no-wrap
+msgid ""
+"(define* (install #:allow-other-keys)\n"
+" ;; Install files to the prefix 'configure' specified.\n"
+" (invoke \"make\" \"install\"))\n"
+"\n"
+msgstr ""
+"(define* (install #:allow-other-keys)\n"
+" ;; Dateien ins bei 'configure' festgelegte Präfix installieren.\n"
+" (invoke \"make\" \"install\"))\n"
+"\n"
+
+#. type: lisp
+#: doc/guix.texi:7791
+#, no-wrap
+msgid ""
+"(define %standard-phases\n"
+" ;; The list of standard phases (quite a few are omitted\n"
+" ;; for brevity). Each element is a symbol/procedure pair.\n"
+" (list (cons 'unpack unpack)\n"
+" (cons 'configure configure)\n"
+" (cons 'build build)\n"
+" (cons 'check check)\n"
+" (cons 'install install)))\n"
+msgstr ""
+"(define %standard-phases\n"
+" ;; Die Liste der Standardphasen (der Kürze halber lassen wir einige\n"
+" ;; aus). Jedes Element ist ein Paar aus Symbol und Prozedur.\n"
+" (list (cons 'unpack unpack)\n"
+" (cons 'configure configure)\n"
+" (cons 'build build)\n"
+" (cons 'check check)\n"
+" (cons 'install install)))\n"
+
+#. type: Plain text
+#: doc/guix.texi:7801
+msgid "This shows how @code{%standard-phases} is defined as a list of symbol/procedure pairs (@pxref{Pairs,,, guile, GNU Guile Reference Manual}). The first pair associates the @code{unpack} procedure with the @code{unpack} symbol---a name; the second pair defines the @code{configure} phase similarly, and so on. When building a package that uses @code{gnu-build-system} with its default list of phases, those phases are executed sequentially. You can see the name of each phase started and completed in the build log of packages that you build."
+msgstr "Hier sieht man wie @code{%standard-phases} als eine Liste von Paaren aus Symbol und Prozedur (siehe @ref{Pairs,,, guile, Referenzhandbuch zu GNU Guile}) definiert ist. Das erste Paar assoziiert die @code{unpack}-Prozedur mit dem @code{unpack}-Symbol — es gibt einen Namen an. Das zweite Paar definiert die @code{configure}-Phase auf ähnliche Weise, ebenso die anderen. Wenn ein Paket erstellt wird, das @code{gnu-build-system} benutzt, werden diese Phasen der Reihe nach ausgeführt. Sie können beim Erstellen von Paketen im Erstellungsprotokoll den Namen jeder gestarteten und abgeschlossenen Phase sehen."
+
+#. type: Plain text
+#: doc/guix.texi:7807
+msgid "Let's now look at the procedures themselves. Each one is defined with @code{define*}: @code{#:key} lists keyword parameters the procedure accepts, possibly with a default value, and @code{#:allow-other-keys} specifies that other keyword parameters are ignored (@pxref{Optional Arguments,,, guile, GNU Guile Reference Manual})."
+msgstr "Schauen wir uns jetzt die Prozeduren selbst an. Jede davon wird mit @code{define*} definiert, dadurch können bei @code{#:key} die Schlüsselwortparameter aufgelistet werden, die die Prozedur annimmt, wenn gewünscht auch zusammen mit einem Vorgabewert, und durch @code{#:allow-other-keys} wird veranlasst, dass andere Schlüsselwortparameter ignoriert werden (siehe @ref{Optional Arguments,,, guile, Referenzhandbuch zu GNU Guile})."
+
+#. type: Plain text
+#: doc/guix.texi:7823
+msgid "The @code{unpack} procedure honors the @code{source} parameter, which the build system uses to pass the file name of the source tarball (or version control checkout), and it ignores other parameters. The @code{configure} phase only cares about the @code{outputs} parameter, an alist mapping package output names to their store file name (@pxref{Packages with Multiple Outputs}). It extracts the file name of for @code{out}, the default output, and passes it to @command{./configure} as the installation prefix, meaning that @command{make install} will eventually copy all the files in that directory (@pxref{Configuration, configuration and makefile conventions,, standards, GNU Coding Standards}). @code{build} and @code{install} ignore all their arguments. @code{check} honors the @code{test-target} argument, which specifies the name of the Makefile target to run tests; it prints a message and skips tests when @code{tests?} is false."
+msgstr "Die @code{unpack}-Prozedur berücksichtigt den @code{source}-Parameter; das Erstellungssystem benutzt ihn, um den Dateinamen des Quell-Tarballs (oder des Checkouts aus einer Versionskontrolle) zu finden. Die anderen Parameter ignoriert sie. Die @code{configure}-Phase interessiert sich nur für den @code{outputs}-Parameter, eine Alist, die die Namen von Paketausgaben auf ihre Dateinamen im Store abbildet (siehe @ref{Packages with Multiple Outputs}). Sie extrahiert den Dateinamen für @code{out}, die Standardausgabe, und gibt ihn an @command{./configure} als das Installationspräfix weiter, wodurch @command{make install} zum Schluss alle Dateien in dieses Verzeichnis kopieren wird (siehe @ref{Configuration, configuration and makefile conventions,, standards, GNU Coding Standards}). @code{build} und @code{install} ignorieren all ihre Argumente. @code{check} berücksichtigt das Argument @code{test-target}, worin der Name des Makefile-Ziels angegeben wird, um die Tests auszuführen. Es wird stattdessen eine Nachricht angezeigt und die Tests übersprungen, wenn @code{tests?} falsch ist."
+
+#. type: cindex
+#: doc/guix.texi:7824
+#, no-wrap
+msgid "build phases, customizing"
+msgstr "Erstellungsphasen, Anpassen der"
+
+#. type: Plain text
+#: doc/guix.texi:7833
+msgid "The list of phases used for a particular package can be changed with the @code{#:phases} parameter of the build system. Changing the set of build phases boils down to building a new alist of phases based on the @code{%standard-phases} alist described above. This can be done with standard alist procedures such as @code{alist-delete} (@pxref{SRFI-1 Association Lists,,, guile, GNU Guile Reference Manual}); however, it is more convenient to do so with @code{modify-phases} (@pxref{Build Utilities, @code{modify-phases}})."
+msgstr "Die Liste der Phasen, die für ein bestimmtes Paket benutzt werden, kann über den @code{#:phases}-Parameter an das Erstellungssystem geändert werden. Das Ändern des Satzes von Erstellungsphasen funktioniert so, dass eine neue Alist von Phasen aus der oben beschriebenen @code{%standard-phases}-Alist heraus erzeugt wird. Dazu können die Standardprozeduren zur Bearbeitung von assoziativen Listen wie @code{alist-delete} benutzt werden (siehe @ref{SRFI-1 Association Lists,,, guile, Referenzhandbuch zu GNU Guile}), aber es ist bequemer, dafür die Prozedur @code{modify-phases} zu benutzen (siehe @ref{Build Utilities, @code{modify-phases}})."
+
+#. type: Plain text
+#: doc/guix.texi:7838
+msgid "Here is an example of a package definition that removes the @code{configure} phase of @code{%standard-phases} and inserts a new phase before the @code{build} phase, called @code{set-prefix-in-makefile}:"
+msgstr "Hier ist ein Beispiel für eine Paketdefinition, die die @code{configure}-Phase aus @code{%standard-phases} entfernt und eine neue Phase vor der @code{build}-Phase namens @code{set-prefix-in-makefile} einfügt:"
+
+#. type: lisp
+#: doc/guix.texi:7858
+#, no-wrap
+msgid ""
+"(define-public example\n"
+" (package\n"
+" (name \"example\")\n"
+" ;; other fields omitted\n"
+" (build-system gnu-build-system)\n"
+" (arguments\n"
+" '(#:phases (modify-phases %standard-phases\n"
+" (delete 'configure)\n"
+" (add-before 'build 'set-prefix-in-makefile\n"
+" (lambda* (#:key outputs #:allow-other-keys)\n"
+" ;; Modify the makefile so that its\n"
+" ;; 'PREFIX' variable points to \"out\".\n"
+" (let ((out (assoc-ref outputs \"out\")))\n"
+" (substitute* \"Makefile\"\n"
+" ((\"PREFIX =.*\")\n"
+" (string-append \"PREFIX = \"\n"
+" out \"\\n\")))\n"
+" #true))))))))\n"
+msgstr ""
+"(define-public beispiel\n"
+" (package\n"
+" (name \"beispiel\")\n"
+" ;; wir lassen die anderen Felder aus\n"
+" (build-system gnu-build-system)\n"
+" (arguments\n"
+" '(#:phases (modify-phases %standard-phases\n"
+" (delete 'configure)\n"
+" (add-before 'build 'set-prefix-in-makefile\n"
+" (lambda* (#:key outputs #:allow-other-keys)\n"
+" ;; Makefile anpassen, damit die 'PREFIX'-\n"
+" ;; Variable auf \"out\" verweist.\n"
+" (let ((out (assoc-ref outputs \"out\")))\n"
+" (substitute* \"Makefile\"\n"
+" ((\"PREFIX =.*\")\n"
+" (string-append \"PREFIX = \"\n"
+" out \"\\n\")))\n"
+" #true))))))))\n"
+
+#. type: Plain text
+#: doc/guix.texi:7864
+msgid "The new phase that is inserted is written as an anonymous procedure, introduced with @code{lambda*}; it honors the @code{outputs} parameter we have seen before. @xref{Build Utilities}, for more about the helpers used by this phase, and for more examples of @code{modify-phases}."
+msgstr "Die neu eingefügte Phase wurde als anonyme Prozedur geschrieben. Solche namenlosen Prozeduren schreibt man mit @code{lambda*}. Oben berücksichtigt sie den @code{outputs}-Parameter, den wir zuvor gesehen haben. Siehe @ref{Build Utilities} für mehr Informationen über die in dieser Phase benutzten Hilfsmittel und für mehr Beispiele zu @code{modify-phases}."
+
+#. type: cindex
+#: doc/guix.texi:7865 doc/guix.texi:8838
+#, no-wrap
+msgid "code staging"
+msgstr "Code-Staging"
+
+#. type: cindex
+#: doc/guix.texi:7866 doc/guix.texi:8839
+#, no-wrap
+msgid "staging, of code"
+msgstr "Staging, von Code"
+
+#. type: Plain text
+#: doc/guix.texi:7873
+msgid "Keep in mind that build phases are code evaluated at the time the package is actually built. This explains why the whole @code{modify-phases} expression above is quoted (it comes after the @code{'} or apostrophe): it is @dfn{staged} for later execution. @xref{G-Expressions}, for an explanation of code staging and the @dfn{code strata} involved."
+msgstr "Sie sollten im Kopf behalten, dass Erstellungsphasen aus Code bestehen, der erst dann ausgewertet wird, wenn das Paket erstellt wird. Das ist der Grund, warum der gesamte @code{modify-phases}-Ausdruck oben quotiert wird. Quotiert heißt, er steht nach einem @code{'} oder Apostrophenzeichen: Er wird nicht sofort als Code ausgewertet, sondern nur zur späteren Ausführung vorgemerkt (wir sagen @dfn{staged}, siehe @ref{G-Expressions} für eine Erläuterung von Code-Staging und den beteiligten @dfn{Code-Schichten} (oder „Strata“)."
+
+#. type: Plain text
+#: doc/guix.texi:7883
+msgid "As soon as you start writing non-trivial package definitions (@pxref{Defining Packages}) or other build actions (@pxref{G-Expressions}), you will likely start looking for helpers for ``shell-like'' actions---creating directories, copying and deleting files recursively, manipulating build phases, and so on. The @code{(guix build utils)} module provides such utility procedures."
+msgstr "Sobald Sie anfangen, nichttriviale Paketdefinitionen (siehe @ref{Defining Packages}) oder andere Erstellungsaktionen (siehe @ref{G-Expressions}) zu schreiben, würden Sie sich wahrscheinlich darüber freuen, Helferlein für „Shell-artige“ Aktionen vordefiniert zu bekommen, also Code, den Sie benutzen können, um Verzeichnisse anzulegen, Dateien rekursiv zu kopieren oder zu löschen, Erstellungsphasen anzupassen und Ähnliches. Das Modul @code{(guix build utils)} macht solche nützlichen Werkzeugprozeduren verfügbar."
+
+#. type: Plain text
+#: doc/guix.texi:7887
+msgid "Most build systems load @code{(guix build utils)} (@pxref{Build Systems}). Thus, when writing custom build phases for your package definitions, you can usually assume those procedures are in scope."
+msgstr "Die meisten Erstellungssysteme laden @code{(guix build utils)} (siehe @ref{Build Systems}). Wenn Sie also eigene Erstellungsphasen für Ihre Paketdefinitionen schreiben, können Sie in den meisten Fällen annehmen, dass diese Prozeduren bei der Auswertung sichtbar sein werden."
+
+#. type: Plain text
+#: doc/guix.texi:7892
+msgid "When writing G-expressions, you can import @code{(guix build utils)} on the ``build side'' using @code{with-imported-modules} and then put it in scope with the @code{use-modules} form (@pxref{Using Guile Modules,,, guile, GNU Guile Reference Manual}):"
+msgstr "Beim Schreiben von G-Ausdrücken können Sie auf der „Erstellungsseite“ @code{(guix build utils)} mit @code{with-imported-modules} importieren und anschließend mit der @code{use-modules}-Form sichtbar machen (siehe @ref{Using Guile Modules,,, guile, Referenzhandbuch zu GNU Guile}):"
+
+#. type: lisp
+#: doc/guix.texi:7899
+#, no-wrap
+msgid ""
+"(with-imported-modules '((guix build utils)) ;import it\n"
+" (computed-file \"empty-tree\"\n"
+" #~(begin\n"
+" ;; Put it in scope.\n"
+" (use-modules (guix build utils))\n"
+"\n"
+msgstr ""
+"(with-imported-modules '((guix build utils)) ;importieren\n"
+" (computed-file \"leerer-verzeichnisbaum\"\n"
+" #~(begin\n"
+" ;; Sichtbar machen.\n"
+" (use-modules (guix build utils))\n"
+"\n"
+
+#. type: lisp
+#: doc/guix.texi:7902
+#, no-wrap
+msgid ""
+" ;; Happily use its 'mkdir-p' procedure.\n"
+" (mkdir-p (string-append #$output \"/a/b/c\")))))\n"
+msgstr ""
+" ;; Jetzt kann man problemlos 'mkdir-p' nutzen.\n"
+" (mkdir-p (string-append #$output \"/a/b/c\")))))\n"
+
+#. type: Plain text
+#: doc/guix.texi:7906
+msgid "The remainder of this section is the reference for most of the utility procedures provided by @code{(guix build utils)}."
+msgstr "Der Rest dieses Abschnitts stellt eine Referenz der meisten Werkzeugprozeduren dar, die @code{(guix build utils)} anbietet."
+
+#. type: subsection
+#: doc/guix.texi:7909
+#, no-wrap
+msgid "Dealing with Store File Names"
+msgstr "Umgehen mit Store-Dateinamen"
+
+#. type: Plain text
+#: doc/guix.texi:7912
+msgid "This section documents procedures that deal with store file names."
+msgstr "Dieser Abschnitt dokumentiert Prozeduren, die sich mit Dateinamen von Store-Objekten befassen."
+
+#. type: deffn
+#: doc/guix.texi:7913
+#, no-wrap
+msgid "{Scheme Procedure} %store-directory"
+msgstr "{Scheme-Prozedur} %store-directory"
+
+#. type: deffn
+#: doc/guix.texi:7915
+msgid "Return the directory name of the store."
+msgstr "Liefert den Verzeichnisnamen des Stores."
+
+#. type: deffn
+#: doc/guix.texi:7917
+#, no-wrap
+msgid "{Scheme Procedure} store-file-name? @var{file}"
+msgstr "{Scheme-Prozedur} store-file-name? @var{Datei}"
+
+#. type: deffn
+#: doc/guix.texi:7919
+msgid "Return true if @var{file} is in the store."
+msgstr "Liefert wahr zurück, wenn sich @var{Datei} innerhalb des Stores befindet."
+
+#. type: deffn
+#: doc/guix.texi:7921
+#, no-wrap
+msgid "{Scheme Procedure} strip-store-file-name @var{file}"
+msgstr "{Scheme-Prozedur} strip-store-file-name @var{Datei}"
+
+#. type: deffn
+#: doc/guix.texi:7924
+msgid "Strip the @file{/gnu/store} and hash from @var{file}, a store file name. The result is typically a @code{\"@var{package}-@var{version}\"} string."
+msgstr "Liefert den Namen der @var{Datei}, die im Store liegt, ohne den Anfang @file{/gnu/store} und ohne die Prüfsumme am Namensanfang. Als Ergebnis ergibt sich typischerweise eine Zeichenkette aus @code{\"@var{Paket}-@var{Version}\"}."
+
+#. type: deffn
+#: doc/guix.texi:7926
+#, no-wrap
+msgid "{Scheme Procedure} package-name->name+version @var{name}"
+msgstr "{Scheme-Prozedur} package-name->name+version @var{Name}"
+
+#. type: deffn
+#: doc/guix.texi:7931
+msgid "Given @var{name}, a package name like @code{\"foo-0.9.1b\"}, return two values: @code{\"foo\"} and @code{\"0.9.1b\"}. When the version part is unavailable, @var{name} and @code{#f} are returned. The first hyphen followed by a digit is considered to introduce the version part."
+msgstr "Liefert für den Paket-@var{Name}n (so etwas wie @code{\"foo-0.9.1b\"}) zwei Werte zurück: zum einen @code{\"foo\"} und zum anderen @code{\"0.9.1b\"}. Wenn der Teil mit der Version fehlt, werden der @var{Name} und @code{#f} zurückgeliefert. Am ersten Bindestrich, auf den eine Ziffer folgt, wird der Versionsteil abgetrennt."
+
+#. type: subsection
+#: doc/guix.texi:7933
+#, no-wrap
+msgid "File Types"
+msgstr "Dateitypen"
+
+#. type: Plain text
+#: doc/guix.texi:7936
+msgid "The procedures below deal with files and file types."
+msgstr "Bei den folgenden Prozeduren geht es um Dateien und Dateitypen."
+
+#. type: deffn
+#: doc/guix.texi:7937
+#, no-wrap
+msgid "{Scheme Procedure} directory-exists? @var{dir}"
+msgstr "{Scheme-Prozedur} directory-exists? @var{Verzeichnis}"
+
+#. type: deffn
+#: doc/guix.texi:7939
+msgid "Return @code{#t} if @var{dir} exists and is a directory."
+msgstr "Liefert @code{#t}, wenn das @var{Verzeichnis} existiert und ein Verzeichnis ist."
+
+#. type: deffn
+#: doc/guix.texi:7941
+#, no-wrap
+msgid "{Scheme Procedure} executable-file? @var{file}"
+msgstr "{Scheme-Prozedur} executable-file? @var{Datei}"
+
+#. type: deffn
+#: doc/guix.texi:7943
+msgid "Return @code{#t} if @var{file} exists and is executable."
+msgstr "Liefert @code{#t}, wenn die @var{Datei} existiert und ausführbar ist."
+
+#. type: deffn
+#: doc/guix.texi:7945
+#, no-wrap
+msgid "{Scheme Procedure} symbolic-link? @var{file}"
+msgstr "{Scheme-Prozedur} symbolic-link? @var{Datei}"
+
+#. type: deffn
+#: doc/guix.texi:7947
+msgid "Return @code{#t} if @var{file} is a symbolic link (aka. a ``symlink'')."
+msgstr "Liefert @code{#t}, wenn die @var{Datei} eine symbolische Verknüpfung ist (auch bekannt als „Symlink“)."
+
+#. type: deffn
+#: doc/guix.texi:7949
+#, no-wrap
+msgid "{Scheme Procedure} elf-file? @var{file}"
+msgstr "{Scheme-Prozedur} elf-file? @var{Datei}"
+
+#. type: deffnx
+#: doc/guix.texi:7950
+#, no-wrap
+msgid "{Scheme Procedure} ar-file? @var{file}"
+msgstr "{Scheme-Prozedur} ar-file? @var{Datei}"
+
+#. type: deffnx
+#: doc/guix.texi:7951
+#, no-wrap
+msgid "{Scheme Procedure} gzip-file? @var{file}"
+msgstr "{Scheme-Prozedur} gzip-file? @var{Datei}"
+
+#. type: deffn
+#: doc/guix.texi:7954
+msgid "Return @code{#t} if @var{file} is, respectively, an ELF file, an @code{ar} archive (such as a @file{.a} static library), or a gzip file."
+msgstr "Liefert @code{#t}, wenn die @var{Datei} jeweils eine ELF-Datei, ein @code{ar}-Archiv (etwa eine statische Bibliothek mit @file{.a}) oder eine gzip-Datei ist."
+
+#. type: deffn
+#: doc/guix.texi:7956
+#, no-wrap
+msgid "{Scheme Procedure} reset-gzip-timestamp @var{file} [#:keep-mtime? #t]"
+msgstr "{Scheme-Prozedur} reset-gzip-timestamp @var{Datei} [#:keep-mtime? #t]"
+
+#. type: deffn
+#: doc/guix.texi:7960
+msgid "If @var{file} is a gzip file, reset its embedded timestamp (as with @command{gzip --no-name}) and return true. Otherwise return @code{#f}. When @var{keep-mtime?} is true, preserve @var{file}'s modification time."
+msgstr "Wenn die @var{Datei} eine gzip-Datei ist, wird ihr eingebetteter Zeitstempel zurückgesetzt (wie bei @command{gzip --no-name}) und wahr geliefert. Ansonsten wird @code{#f} geliefert. Wenn @var{keep-mtime?} wahr ist, wird der Zeitstempel der letzten Modifikation von @var{Datei} beibehalten."
+
+#. type: subsection
+#: doc/guix.texi:7962
+#, no-wrap
+msgid "File Manipulation"
+msgstr "Änderungen an Dateien"
+
+#. type: Plain text
+#: doc/guix.texi:7969
+msgid "The following procedures and macros help create, modify, and delete files. They provide functionality comparable to common shell utilities such as @command{mkdir -p}, @command{cp -r}, @command{rm -r}, and @command{sed}. They complement Guile's extensive, but low-level, file system interface (@pxref{POSIX,,, guile, GNU Guile Reference Manual})."
+msgstr "Die folgenden Prozeduren und Makros helfen beim Erstellen, Ändern und Löschen von Dateien. Sie machen Funktionen ähnlich zu Shell-Werkzeugen wie @command{mkdir -p}, @command{cp -r}, @command{rm -r} und @command{sed} verfügbar. Sie ergänzen Guiles ausgiebige aber kleinschrittige Dateisystemschnittstelle (siehe @ref{POSIX,,, guile, Referenzhandbuch zu GNU Guile})."
+
+#. type: deffn
+#: doc/guix.texi:7970
+#, no-wrap
+msgid "{Scheme Syntax} with-directory-excursion @var{directory} @var{body}@dots{}"
+msgstr "{Scheme-Syntax} with-directory-excursion @var{Verzeichnis} @var{Rumpf}…"
+
+#. type: deffn
+#: doc/guix.texi:7972
+msgid "Run @var{body} with @var{directory} as the process's current directory."
+msgstr "Den @var{Rumpf} ausführen mit dem @var{Verzeichnis} als aktuellem Verzeichnis des Prozesses."
+
+#. type: deffn
+#: doc/guix.texi:7979
+msgid "Essentially, this macro changes the current directory to @var{directory} before evaluating @var{body}, using @code{chdir} (@pxref{Processes,,, guile, GNU Guile Reference Manual}). It changes back to the initial directory when the dynamic extent of @var{body} is left, be it @i{via} normal procedure return or @i{via} a non-local exit such as an exception."
+msgstr "Im Grunde ändert das Makro das aktuelle Arbeitsverzeichnis auf @var{Verzeichnis} bevor der @var{Rumpf} ausgewertet wird, mittels @code{chdir} (siehe @ref{Processes,,, guile, Referenzhandbuch zu GNU Guile}). Wenn der dynamische Bereich von @var{Rumpf} wieder verlassen wird, wechselt es wieder ins anfängliche Verzeichnis zurück, egal ob der @var{Rumpf} durch normales Zurückliefern eines Ergebnisses oder durch einen nichtlokalen Sprung wie etwa eine Ausnahme verlassen wurde."
+
+#. type: deffn
+#: doc/guix.texi:7981
+#, no-wrap
+msgid "{Scheme Procedure} mkdir-p @var{dir}"
+msgstr "{Scheme-Prozedur} mkdir-p @var{Verzeichnis}"
+
+#. type: deffn
+#: doc/guix.texi:7983
+msgid "Create directory @var{dir} and all its ancestors."
+msgstr "Das @var{Verzeichnis} und all seine Vorgänger erstellen."
+
+#. type: deffn
+#: doc/guix.texi:7985
+#, no-wrap
+msgid "{Scheme Procedure} install-file @var{file} @var{directory}"
+msgstr "{Scheme-Prozedur} install-file @var{Datei} @var{Verzeichnis}"
+
+#. type: deffn
+#: doc/guix.texi:7988
+msgid "Create @var{directory} if it does not exist and copy @var{file} in there under the same name."
+msgstr "@var{Verzeichnis} erstellen, wenn es noch nicht existiert, und die @var{Datei} mit ihrem Namen dorthin kopieren."
+
+#. type: deffn
+#: doc/guix.texi:7990
+#, no-wrap
+msgid "{Scheme Procedure} make-file-writable @var{file}"
+msgstr "{Scheme-Prozedur} make-file-writable @var{Datei}"
+
+#. type: deffn
+#: doc/guix.texi:7992
+msgid "Make @var{file} writable for its owner."
+msgstr "Dem Besitzer der @var{Datei} Schreibberechtigung darauf erteilen."
+
+#. type: deffn
+#: doc/guix.texi:7994
+#, no-wrap
+msgid "{Scheme Procedure} copy-recursively @var{source} @var{destination} @"
+msgstr "{Scheme-Prozedur} copy-recursively @var{Quelle} @var{Zielort} @"
+
+#. type: deffn
+#: doc/guix.texi:8001
+msgid "[#:log (current-output-port)] [#:follow-symlinks? #f] [#:keep-mtime? #f] Copy @var{source} directory to @var{destination}. Follow symlinks if @var{follow-symlinks?} is true; otherwise, just preserve them. When @var{keep-mtime?} is true, keep the modification time of the files in @var{source} on those of @var{destination}. Write verbose output to the @var{log} port."
+msgstr "[#:log (current-output-port)] [#:follow-symlinks? #f] [#:keep-mtime? #f] Das Verzeichnis @var{Quelle} rekursiv an den @var{Zielort} kopieren. Wenn @var{follow-symlinks?} wahr ist, folgt die Rekursion symbolischen Verknüpfungen, ansonsten werden die Verknüpfungen als solche beibehalten. Wenn @var{keep-mtime?} wahr ist, bleibt der Zeitstempel der letzten Änderung an den Dateien in @var{Quelle} dabei bei denen am @var{Zielort} erhalten. Ein ausführliches Protokoll wird in den bei @var{log} angegebenen Port geschrieben."
+
+#. type: deffn
+#: doc/guix.texi:8003
+#, no-wrap
+msgid "{Scheme Procedure} delete-file-recursively @var{dir} @"
+msgstr "{Scheme-Prozedur} delete-file-recursively @var{Verzeichnis} @"
+
+#. type: deffn
+#: doc/guix.texi:8008
+msgid "[#:follow-mounts? #f] Delete @var{dir} recursively, like @command{rm -rf}, without following symlinks. Don't follow mount points either, unless @var{follow-mounts?} is true. Report but ignore errors."
+msgstr "[#:follow-mounts? #f] Das @var{Verzeichnis} rekursiv löschen, wie bei @command{rm -rf}, ohne symbolischen Verknüpfungen zu folgen. Auch Einhängepunkten wird @emph{nicht} gefolgt, außer falls @var{follow-mounts?} wahr ist. Fehler dabei werden angezeigt aber ignoriert."
+
+#. type: deffn
+#: doc/guix.texi:8010
+#, no-wrap
+msgid "{Scheme Syntax} substitute* @var{file} @"
+msgstr "{Scheme-Syntax} substitute* @var{Datei} @"
+
+#. type: deffn
+#: doc/guix.texi:8015
+msgid "((@var{regexp} @var{match-var}@dots{}) @var{body}@dots{}) @dots{} Substitute @var{regexp} in @var{file} by the string returned by @var{body}. @var{body} is evaluated with each @var{match-var} bound to the corresponding positional regexp sub-expression. For example:"
+msgstr "((@var{Regexp} @var{Muster-Variable}@dots{}) @var{Rumpf}…) … Den regulären Ausdruck @var{Regexp} in der @var{Datei} durch die durch @var{Rumpf} berechnete Zeichenkette ersetzen. Bei der Auswertung von @var{Rumpf} wird jede @var{Muster-Variable} an den Teilausdruck an der entsprechenden Position der Regexp gebunden. Zum Beispiel:"
+
+#. type: lisp
+#: doc/guix.texi:8022
+#, no-wrap
+msgid ""
+"(substitute* file\n"
+" ((\"hello\")\n"
+" \"good morning\\n\")\n"
+" ((\"foo([a-z]+)bar(.*)$\" all letters end)\n"
+" (string-append \"baz\" letter end)))\n"
+msgstr ""
+"(substitute* file\n"
+" ((\"Hallo\")\n"
+" \"Guten Morgen\\n\")\n"
+" ((\"foo([a-z]+)bar(.*)$\" alles Buchstaben Ende)\n"
+" (string-append \"baz\" Buchstaben Ende)))\n"
+
+#. type: deffn
+#: doc/guix.texi:8028
+msgid "Here, anytime a line of @var{file} contains @code{hello}, it is replaced by @code{good morning}. Anytime a line of @var{file} matches the second regexp, @code{all} is bound to the complete match, @code{letters} is bound to the first sub-expression, and @code{end} is bound to the last one."
+msgstr "Jedes Mal, wenn eine Zeile in der @var{Datei} den Text @code{Hallo} enthält, wird dieser durch @code{Guten Morgen} ersetzt. Jedes Mal, wenn eine Zeile zum zweiten regulären Ausdruck passt, wird @code{alles} an die vollständige Übereinstimmung gebunden, @code{Buchstaben} wird an den ersten Teilausdruck gebunden und @code{Ende} an den letzten."
+
+#. type: deffn
+#: doc/guix.texi:8031
+msgid "When one of the @var{match-var} is @code{_}, no variable is bound to the corresponding match substring."
+msgstr "Wird für eine @var{Muster-Variable} nur @code{_} geschrieben, so wird keine Variable an die Teilzeichenkette an der entsprechenden Position im Muster gebunden."
+
+#. type: deffn
+#: doc/guix.texi:8034
+msgid "Alternatively, @var{file} may be a list of file names, in which case they are all subject to the substitutions."
+msgstr "Alternativ kann statt einer @var{Datei} auch eine Liste von Dateinamen angegeben werden. In diesem Fall wird jede davon den Substitutionen unterzogen."
+
+#. type: deffn
+#: doc/guix.texi:8037
+msgid "Be careful about using @code{$} to match the end of a line; by itself it won't match the terminating newline of a line."
+msgstr "Seien Sie vorsichtig bei der Nutzung von @code{$}, um auf das Ende einer Zeile zu passen. @code{$} passt nämlich @emph{nicht} auf den Zeilenumbruch am Ende einer Zeile."
+
+#. type: subsection
+#: doc/guix.texi:8039
+#, no-wrap
+msgid "File Search"
+msgstr "Dateien suchen"
+
+#. type: cindex
+#: doc/guix.texi:8041
+#, no-wrap
+msgid "file, searching"
+msgstr "Dateien, suchen"
+
+#. type: Plain text
+#: doc/guix.texi:8043
+msgid "This section documents procedures to search and filter files."
+msgstr "Dieser Abschnitt beschreibt Prozeduren, um Dateien zu suchen und zu filtern."
+
+#. type: deffn
+#: doc/guix.texi:8044
+#, no-wrap
+msgid "{Scheme Procedure} file-name-predicate @var{regexp}"
+msgstr "{Scheme-Prozedur} file-name-predicate @var{Regexp}"
+
+#. type: deffn
+#: doc/guix.texi:8047
+msgid "Return a predicate that returns true when passed a file name whose base name matches @var{regexp}."
+msgstr "Liefert ein Prädikat, das gegeben einen Dateinamen, dessen Basisnamen auf @var{Regexp} passt, wahr liefert."
+
+#. type: deffn
+#: doc/guix.texi:8049
+#, no-wrap
+msgid "{Scheme Procedure} find-files @var{dir} [@var{pred}] @"
+msgstr "{Scheme-Prozedur} find-files @var{Verzeichnis} [@var{Prädikat}] @"
+
+#. type: deffn
+#: doc/guix.texi:8060
+msgid "[#:stat lstat] [#:directories? #f] [#:fail-on-error? #f] Return the lexicographically sorted list of files under @var{dir} for which @var{pred} returns true. @var{pred} is passed two arguments: the absolute file name, and its stat buffer; the default predicate always returns true. @var{pred} can also be a regular expression, in which case it is equivalent to @code{(file-name-predicate @var{pred})}. @var{stat} is used to obtain file information; using @code{lstat} means that symlinks are not followed. If @var{directories?} is true, then directories will also be included. If @var{fail-on-error?} is true, raise an exception upon error."
+msgstr "[#:stat lstat] [#:directories? #f] [#:fail-on-error? #f] Liefert die lexikografisch sortierte Liste der Dateien innerhalb @var{Verzeichnis}, für die das @var{Prädikat} wahr liefert. An @var{Prädikat} werden zwei Argumente übergeben: Der absolute Dateiname und der zugehörige Stat-Puffer. Das vorgegebene Prädikat liefert immer wahr. Als @var{Prädikat} kann auch ein regulärer Ausdruck benutzt werden; in diesem Fall ist er äquivalent zu @code{(file-name-predicate @var{Prädikat})}. Mit @var{stat} werden Informationen über die Datei ermittelt; wenn dafür @code{lstat} benutzt wird, bedeutet das, dass symbolische Verknüpfungen nicht verfolgt werden. Wenn @var{directories?} wahr ist, dann werden auch Verzeichnisse aufgezählt. Wenn @var{fail-on-error?} wahr ist, dann wird bei einem Fehler eine Ausnahme ausgelöst."
+
+#. type: Plain text
+#: doc/guix.texi:8064
+msgid "Here are a few examples where we assume that the current directory is the root of the Guix source tree:"
+msgstr "Nun folgen ein paar Beispiele, wobei wir annehmen, dass das aktuelle Verzeichnis der Wurzel des Guix-Quellbaums entspricht."
+
+#. type: lisp
+#: doc/guix.texi:8069
+#, no-wrap
+msgid ""
+";; List all the regular files in the current directory.\n"
+"(find-files \".\")\n"
+"@result{} (\"./.dir-locals.el\" \"./.gitignore\" @dots{})\n"
+"\n"
+msgstr ""
+";; Alle regulären Dateien im aktuellen Verzeichnis auflisten.\n"
+"(find-files \".\")\n"
+"@result{} (\"./.dir-locals.el\" \"./.gitignore\" …)\n"
+"\n"
+
+#. type: lisp
+#: doc/guix.texi:8073
+#, no-wrap
+msgid ""
+";; List all the .scm files under gnu/services.\n"
+"(find-files \"gnu/services\" \"\\\\.scm$\")\n"
+"@result{} (\"gnu/services/admin.scm\" \"gnu/services/audio.scm\" @dots{})\n"
+"\n"
+msgstr ""
+";; Alle .scm-Dateien unter gnu/services auflisten.\n"
+"(find-files \"gnu/services\" \"\\\\.scm$\")\n"
+"@result{} (\"gnu/services/admin.scm\" \"gnu/services/audio.scm\" …)\n"
+"\n"
+
+#. type: lisp
+#: doc/guix.texi:8077
+#, no-wrap
+msgid ""
+";; List ar files in the current directory.\n"
+"(find-files \".\" (lambda (file stat) (ar-file? file)))\n"
+"@result{} (\"./libformat.a\" \"./libstore.a\" @dots{})\n"
+msgstr ""
+";; ar-Dateien im aktuellen Verzeichnis auflisten.\n"
+"(find-files \".\" (lambda (file stat) (ar-file? file)))\n"
+"@result{} (\"./libformat.a\" \"./libstore.a\" …)\n"
+
+#. type: deffn
+#: doc/guix.texi:8079
+#, no-wrap
+msgid "{Scheme Procedure} which @var{program}"
+msgstr "{Scheme-Prozedur} which @var{Programm}"
+
+#. type: deffn
+#: doc/guix.texi:8082
+msgid "Return the complete file name for @var{program} as found in @code{$PATH}, or @code{#f} if @var{program} could not be found."
+msgstr "Liefert den vollständigen Dateinamen für das @var{Programm}, der in @code{$PATH} gesucht wird, oder @code{#f}, wenn das @var{Programm} nicht gefunden werden konnte."
+
+#. type: Plain text
+#: doc/guix.texi:8093
+msgid "The @code{(guix build utils)} also contains tools to manipulate build phases as used by build systems (@pxref{Build Systems}). Build phases are represented as association lists or ``alists'' (@pxref{Association Lists,,, guile, GNU Guile Reference Manual}) where each key is a symbol naming the phase and the associated value is a procedure (@pxref{Build Phases})."
+msgstr "@code{(guix build utils)} enthält auch Werkzeuge, um die von Erstellungssystemen benutzten Erstellungsphasen zu verändern (siehe @ref{Build Systems}). Erstellungsphasen werden durch assoziative Listen oder „Alists“ repräsentiert (siehe @ref{Association Lists,,, guile, Referenzhandbuch zu GNU Guile}), wo jeder Schlüssel ein Symbol ist, das den Namen der Phase angibt, und der assoziierte Wert eine Prozedur ist (siehe @ref{Build Phases})."
+
+#. type: Plain text
+#: doc/guix.texi:8097
+msgid "Guile core and the @code{(srfi srfi-1)} module both provide tools to manipulate alists. The @code{(guix build utils)} module complements those with tools written with build phases in mind."
+msgstr "Die zum Kern von Guile („Guile core“) gehörenden Prozeduren und das Modul @code{(srfi srfi-1)} stellen beide Werkzeuge zum Bearbeiten von Alists zur Verfügung. Das Modul @code{(guix build utils)} ergänzt sie um Werkzeuge, die speziell für Erstellungsphasen gedacht sind."
+
+#. type: cindex
+#: doc/guix.texi:8098
+#, no-wrap
+msgid "build phases, modifying"
+msgstr "Erstellungsphasen, Ändern von"
+
+#. type: deffn
+#: doc/guix.texi:8099
+#, no-wrap
+msgid "{Scheme Syntax} modify-phases @var{phases} @var{clause}@dots{}"
+msgstr "{Scheme-Syntax} modify-phases @var{Phasen} @var{Klausel}…"
+
+#. type: deffn
+#: doc/guix.texi:8102
+msgid "Modify @var{phases} sequentially as per each @var{clause}, which may have one of the following forms:"
+msgstr "Die @var{Phasen} der Reihe nach entsprechend jeder @var{Klausel} ändern. Die Klauseln dürfen eine der folgenden Formen haben:"
+
+#. type: lisp
+#: doc/guix.texi:8108
+#, no-wrap
+msgid ""
+"(delete @var{old-phase-name})\n"
+"(replace @var{old-phase-name} @var{new-phase})\n"
+"(add-before @var{old-phase-name} @var{new-phase-name} @var{new-phase})\n"
+"(add-after @var{old-phase-name} @var{new-phase-name} @var{new-phase})\n"
+msgstr ""
+"(delete @var{alter-Phasenname})\n"
+"(replace @var{alter-Phasenname} @var{neue-Phase})\n"
+"(add-before @var{alter-Phasenname} @var{neuer-Phasenname} @var{neue-Phase})\n"
+"(add-after @var{alter-Phasenname} @var{neuer-Phasenname} @var{neue-Phase})\n"
+
+#. type: deffn
+#: doc/guix.texi:8112
+msgid "Where every @var{phase-name} above is an expression evaluating to a symbol, and @var{new-phase} an expression evaluating to a procedure."
+msgstr "Jeder @var{Phasenname} oben ist ein Ausdruck, der zu einem Symbol auswertet, und @var{neue-Phase} ist ein Ausdruck, der zu einer Prozedur auswertet."
+
+#. type: Plain text
+#: doc/guix.texi:8123
+msgid "The example below is taken from the definition of the @code{grep} package. It adds a phase to run after the @code{install} phase, called @code{fix-egrep-and-fgrep}. That phase is a procedure (@code{lambda*} is for anonymous procedures) that takes a @code{#:outputs} keyword argument and ignores extra keyword arguments (@pxref{Optional Arguments,,, guile, GNU Guile Reference Manual}, for more on @code{lambda*} and optional and keyword arguments.) The phase uses @code{substitute*} to modify the installed @file{egrep} and @file{fgrep} scripts so that they refer to @code{grep} by its absolute file name:"
+msgstr "Folgendes Beispiel stammt aus der Definition des @code{grep}-Pakets. Es fügt eine neue Phase namens @code{egrep-und-fgrep-korrigieren} hinzu, die auf die @code{install}-Phase folgen soll. Diese Phase ist eine Prozedur (@code{lambda*} bedeutet, sie ist eine Prozedur ohne eigenen Namen), die ein Schlüsselwort @code{#:outputs} bekommt und die restlichen Schlüsselwortargumente ignoriert (siehe @ref{Optional Arguments,,, guile, Referenzhandbuch zu GNU Guile} für mehr Informationen zu @code{lambda*} und optionalen sowie Schlüsselwort-Argumenten). In der Phase wird @code{substitute*} benutzt, um die installierten Skripte @file{egrep} und @file{fgrep} so zu verändern, dass sie @code{grep} anhand seines absoluten Dateinamens aufrufen:"
+
+#. type: lisp
+#: doc/guix.texi:8137
+#, no-wrap
+msgid ""
+"(modify-phases %standard-phases\n"
+" (add-after 'install 'fix-egrep-and-fgrep\n"
+" ;; Patch 'egrep' and 'fgrep' to execute 'grep' via its\n"
+" ;; absolute file name instead of searching for it in $PATH.\n"
+" (lambda* (#:key outputs #:allow-other-keys)\n"
+" (let* ((out (assoc-ref outputs \"out\"))\n"
+" (bin (string-append out \"/bin\")))\n"
+" (substitute* (list (string-append bin \"/egrep\")\n"
+" (string-append bin \"/fgrep\"))\n"
+" ((\"^exec grep\")\n"
+" (string-append \"exec \" bin \"/grep\")))\n"
+" #t))))\n"
+msgstr ""
+"(modify-phases %standard-phases\n"
+" (add-after 'install 'egrep-und-fgrep-korrigieren\n"
+" ;; 'egrep' und 'fgrep' patchen, damit diese 'grep' über den\n"
+" ;; absoluten Dateinamen ausführen statt es in $PATH zu suchen.\n"
+" (lambda* (#:key outputs #:allow-other-keys)\n"
+" (let* ((out (assoc-ref outputs \"out\"))\n"
+" (bin (string-append out \"/bin\")))\n"
+" (substitute* (list (string-append bin \"/egrep\")\n"
+" (string-append bin \"/fgrep\"))\n"
+" ((\"^exec grep\")\n"
+" (string-append \"exec \" bin \"/grep\")))\n"
+" #t))))\n"
+
+#. type: Plain text
+#: doc/guix.texi:8144
+msgid "In the example below, phases are modified in two ways: the standard @code{configure} phase is deleted, presumably because the package does not have a @file{configure} script or anything similar, and the default @code{install} phase is replaced by one that manually copies the executable files to be installed:"
+msgstr "In dem Beispiel, das nun folgt, werden Phasen auf zweierlei Art geändert: Die Standard-@code{configure}-Phase wird gelöscht, meistens weil das Paket über kein @file{configure}-Skript oder etwas Ähnliches verfügt, und die vorgegebene @code{install}-Phase wird durch eine ersetzt, in der die zu installierenden ausführbaren Dateien manuell kopiert werden."
+
+#. type: lisp
+#: doc/guix.texi:8157
+#, no-wrap
+msgid ""
+"(modify-phases %standard-phases\n"
+" (delete 'configure) ;no 'configure' script\n"
+" (replace 'install\n"
+" (lambda* (#:key outputs #:allow-other-keys)\n"
+" ;; The package's Makefile doesn't provide an \"install\"\n"
+" ;; rule so do it by ourselves.\n"
+" (let ((bin (string-append (assoc-ref outputs \"out\")\n"
+" \"/bin\")))\n"
+" (install-file \"footswitch\" bin)\n"
+" (install-file \"scythe\" bin)\n"
+" #t))))\n"
+msgstr ""
+"(modify-phases %standard-phases\n"
+" (delete 'configure) ;kein 'configure'-Skript\n"
+" (replace 'install\n"
+" (lambda* (#:key outputs #:allow-other-keys)\n"
+" ;; Das Makefile im Paket enthält kein \"install\"-Ziel,\n"
+" ;; also müssen wir es selber machen.\n"
+" (let ((bin (string-append (assoc-ref outputs \"out\")\n"
+" \"/bin\")))\n"
+" (install-file \"footswitch\" bin)\n"
+" (install-file \"scythe\" bin)\n"
+" #t))))\n"
+
+#. type: cindex
+#: doc/guix.texi:8165