Zen

Translation

(define-public example
(package
(name "example")
;; other fields omitted
(build-system gnu-build-system)
(arguments
'(#:phases (list
#:phases
#~(modify-phases %standard-phases
(delete 'configure)
(add-before 'build 'set-prefix-in-makefile
(lambda* (#:key outinputs #:allow-other-keys)
;; Modify the makefile so that its
;; 'PREFIX' variable points to "out".
#$output and
 (let ((out (assoc-ref outputs "out")))
;; 'XMLLINT' points to the correct path.
 (substitute* "Makefile"
(("PREFIX =.*")
(string-append "PREFIX = " #$output "\n"))
(("XMLLINT =.*")
 (string-append "PREFIXXMLLINT = "
(search-input-file inputs "/bin/xmllint")
 out "\n")))))))))))
English type: lisp
(define-public example
(package
(name "example")
;; other fields omitted
(build-system gnu-build-system)
(arguments
(list
#:phases
#~(modify-phases %standard-phases
(delete 'configure)
(add-before 'build 'set-prefix-in-makefile
(lambda* (#:key inputs #:allow-other-keys)
;; Modify the makefile so that its
;; 'PREFIX' variable points to #$output and
;; 'XMLLINT' points to the correct path.
(substitute* "Makefile"
(("PREFIX =.*")
(string-append "PREFIX = " #$output "\n"))
(("XMLLINT =.*")
(string-append "XMLLINT = "
(search-input-file inputs "/bin/xmllint")
"\n"))))))))))
740/8290 · 829

Sign in to save the translation.

English French Actions
%standard-phases
%standard-phases
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!}:
Par exemple, voici comment @code{(guix build gnu-build-system)} définit @code{%standard-phases}, la variable contenant sa liste de phases de construction@footnote{Nous présentons une vue simplifiée de ces phases de construction, mais jetez un œil à @code{(guix build gnu-build-system)} pour voir tous les détails !} :
;; The build phases of 'gnu-build-system'.
;; Les phases de construction de « gnu-build-system ».
(define* (unpack #:key source #:allow-other-keys)
;; Extract the source tarball.
(invoke "tar" "xvf" source))
(define* (unpack #:key source #:allow-other-keys)
;; Extrait l'archive des sources.
(invoke "tar" "xvf" source))
(define* (configure #:key outputs #:allow-other-keys)
;; Run the 'configure' script. Install to output "out".
(let ((out (assoc-ref outputs "out")))
(invoke "./configure"
(string-append "--prefix=" out))))
(define* (configure #:key outputs #:allow-other-keys)
;; Exécute le script « configure ». Installe la sortie « out ».
(let ((out (assoc-ref outputs "out")))
(invoke "./configure"
(string-append "--prefix=" out))))
(define* (build #:allow-other-keys)
;; Compile.
(invoke "make"))
(define* (build #:allow-other-keys)
;; Compile.
(invoke "make"))
(define* (check #:key (test-target "check") (tests? #true)
#:allow-other-keys)
;; Run the test suite.
(if tests?
(invoke "make" test-target)
(display "test suite not run\n")))
(define* (check #:key (test-target "check") (tests? #true)
#:allow-other-keys)
;; Lance la suite de tests.
(if tests?
(invoke "make" test-target)
(display "test suite not run\n")))
(define* (install #:allow-other-keys)
;; Install files to the prefix 'configure' specified.
(invoke "make" "install"))
(define* (install #:allow-other-keys)
;; Installe les fichiers sous le préfixe spécifié à « configure ».
(invoke "make" "install"))
(define %standard-phases
;; The list of standard phases (quite a few are omitted
;; for brevity). Each element is a symbol/procedure pair.
(list (cons 'unpack unpack)
(cons 'configure configure)
(cons 'build build)
(cons 'check check)
(cons 'install install)))
(define %standard-phases
;; La liste des phases standard (un certain nombre d'entre elles sont omises
;; par souci de concision). Chaque élément est une paire symbole/procédure.
(list (cons 'unpack unpack)
(cons 'configure configure)
(cons 'build build)
(cons 'check check)
(cons 'install install)))
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.
Cela montre comment @code{%standard-phases} est défini comme une liste de paires symbole/procédure (@pxref{Pairs, , , guile, GNU Guile Reference Manual}). La première paire associe le symbole @code{unpack} --- un nom --- à la procédure @code{unpack} ; la deuxième paire définit la phase @code{configure} de manière similaire, et ainsi de suite. Lors de la construction d'un paquet qui utilise @code{gnu-build-system} avec sa liste de phases par défaut, ces phases sont exécutées de manière séquentielle. Vous pouvez voir le nom de chaque phase commencée et terminée dans le journal de construction des paquets que vous construisez.
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}).
Examinons maintenant les procédures elles-mêmes. Chacune est définie par @code{define*} : @code{#:key} énumère les paramètres nommés que la procédure accepte, éventuellement avec une valeur par défaut, et @code{#:allow-other-keys} précise que les autres paramètres nommés sont ignorés (@pxref{Optional Arguments,,, guile, GNU Guile Reference Manual}).
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.
La procédure @code{unpack} prend en compte le paramètre @code{source}, que le système de compilation utilise pour passer le nom de fichier de l'archive source (ou le répertoire cloné d'un système de contrôle de version), et elle ignore les autres paramètres. La phase @code{configure} ne s'intéresse qu'au paramètre @code{outputs}, une liste d'association des noms des sorties du paquet avec le nom de leur fichier du dépôt (@pxref{Packages with Multiple Outputs}). Elle extrait le nom de fichier de @code{out}, la sortie par défaut, et le transmet à @command{./configure} comme préfixe d'installation, ce qui signifie que @command{make install} copiera tous les fichiers vers ce répertoire (@pxref{Configuration, configuration and makefile conventions,, standards, GNU Coding Standards}). @code{build} et @code{install} ignorent tous leurs arguments. @code{check} prend en compte l'argument @code{test-target}, qui spécifie le nom de la cible du Makefile pour exécuter les tests ; il imprime un message et saute les tests lorsque @code{tests?} est faux.
build phases, customizing
phases de construction, personnalisation
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}}).
La liste des phases utilisées pour un paquet particulier peut être modifiée avec le paramètre @code{#:phases} du système de construction. La modification de l'ensemble des phases de construction se résume à la création d'une nouvelle liste de phases basée sur la liste @code{%standard-phases} décrite ci-dessus. On peut faire cela à l'aide des procédures standards qui manipulent des listes d'associations telles que @code{alist-delete} (@pxref{SRFI-1 Association Lists,,, guile, GNU Guile Reference Manual}) ; cependant, il est plus pratique de le faire avec @code{modify-phases} (@pxref{Build Utilities, @code{modify-phases}}).
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}:
Voici un exemple de définition de paquet qui supprime la phase @code{configure} de @code{%standard-phases} et insère une nouvelle phase avant la phase @code{build}, appelée @code{set-prefix-in-makefile} :
(define-public example
(package
(name "example")
;; other fields omitted
(build-system gnu-build-system)
(arguments
(list
#:phases
#~(modify-phases %standard-phases
(delete 'configure)
(add-before 'build 'set-prefix-in-makefile
(lambda* (#:key inputs #:allow-other-keys)
;; Modify the makefile so that its
;; 'PREFIX' variable points to #$output and
;; 'XMLLINT' points to the correct path.
(substitute* "Makefile"
(("PREFIX =.*")
(string-append "PREFIX = " #$output "\n"))
(("XMLLINT =.*")
(string-append "XMLLINT = "
(search-input-file inputs "/bin/xmllint")
"\n"))))))))))
(define-public exemple
(package
(name "exemple")
;; les autres champs sont omis
(build-system gnu-build-system)
(arguments
'(#:phases (modify-phases %standard-phases
(delete 'configure)
(add-before 'build 'set-prefix-in-makefile
(lambda* (#:key outputs #:allow-other-keys)
;; Modifie le Makefile pour que sa variable
;; 'PREFIX' pointe vers « out ».
(let ((out (assoc-ref outputs "out")))
(substitute* "Makefile"
(("PREFIX =.*")
(string-append "PREFIX = "
out "\n")))))))))))
The new phase that is inserted is written as an anonymous procedure, introduced with @code{lambda*}; it looks for the @file{xmllint} executable under a @file{/bin} directory among the package's inputs (@pxref{package Reference}). It also 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}.
La nouvelle phase insérée est écrite comme une procédure anonyme, introduite avec @code{lambda*} ; elle prend en compte le paramètre @code{outputs} que nous avons vu auparavant. @xref{Build Utilities}, pour en savoir plus sur les procédures auxiliaires utilisées par cette phase, et pour d'autres exemples de @code{modify-phases}.
You can inspect the code associated with a package's @code{#:phases} argument interactively, at the REPL (@pxref{Using Guix Interactively}).
 
code staging
code échelonné
staging, of code
échelonnage, du code
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.
Gardez à l'esprit que le code des phases de construction est évalué à la construction effective des paquets. Cela explique pourquoi toute l'expression @code{modify-phases} ci-dessus est citée (elle vient après @code{'} ou apostrophe) : elle est @dfn{mise de côté} pour une exécution ultérieure. @xref{G-Expressions}, pour une explication de la mise en place du code et des @dfn{strates de code} concernées.
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.
Dès que vous commencerez à écrire des définitions de paquets non triviales (@pxref{Defining Packages}) ou d'autres actions de compilation (@pxref{G-Expressions}), vous commencerez probablement à chercher des fonctions auxiliaires pour les actions « de type shell » --- créer des répertoires, copier et supprimer des fichiers de manière récursive, manipuler les phases de compilation, etc. Le module @code{(guix build utils)} fournit de telles procédures utilitaires.
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.
La plupart des systèmes de construction chargent @code{(guix build utils)} (@pxref{Build Systems}). Ainsi, lorsque vous écrivez des phases de construction personnalisées pour vos définitions de paquets, vous pouvez généralement supposer que ces procédures sont disponibles.
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}):
Lorsque vous écrivez des G-expressions, vous pouvez importer @code{(guix build utils)} « côté construction » en utilisant @code{with-imported-modules} et ensuite le rendre disponible avec la forme @code{use-modules} (@pxref{Using Guile Modules,,, guile, GNU Guile Reference Manual}) :
(with-imported-modules '((guix build utils)) ;import it
(computed-file "empty-tree"
#~(begin
;; Put it in scope.
(use-modules (guix build utils))
(with-imported-modules '((guix build utils)) ;on l'importe
(computed-file "empty-tree"
#~(begin
;; On le rend disponible.
(use-modules (guix build utils))
;; Happily use its 'mkdir-p' procedure.
(mkdir-p (string-append #$output "/a/b/c")))))
;; On utilise sa procédure « mkdir-p » sans souci.
(mkdir-p (string-append #$output "/a/b/c")))))
The remainder of this section is the reference for most of the utility procedures provided by @code{(guix build utils)}.
Le reste de cette section est la référence pour la plupart des procédures auxiliaires fournies par @code{(guix build utils)}.
Dealing with Store File Names
Traitement des noms de fichiers du dépôt
This section documents procedures that deal with store file names.
Cette section documente les procédures de traitement des noms de fichier du dépôt.
{Procedure} %store-directory
{Procédure} %store-directory
Return the directory name of the store.
Renvoie le nom de répertoire du dépôt.

Loading…

User avatar None

String updated in the repository

  1. guix
  2. documentation-manual
  3. French
(define-public example
(package
(name "example")
;; other fields omitted
(build-system gnu-build-system)
(arguments
(list
#:phases
#~(modify-phases %standard-phases
(delete 'configure)
(add-before 'build 'set-prefix-in-makefile
(lambda* (#:key inputs #:allow-other-keys)
;; Modify the makefile so that its
;; 'PREFIX' variable points to #$output and
;; 'XMLLINT' points to the correct path.
(substitute* "Makefile"
(("PREFIX =.*")
(string-append "PREFIX = " #$output "\n"))
(("XMLLINT =.*")
(string-append "XMLLINT = "
(search-input-file inputs "/bin/xmllint")
"\n"))))))))))
(define-public exemple
(package
(name "exemple")
;; les autres champs sont omis
(build-system gnu-build-system)
(arguments
'(#:phases (modify-phases %standard-phases
(delete 'configure)
(add-before 'build 'set-prefix-in-makefile
(lambda* (#:key outputs #:allow-other-keys)
;; Modifie le Makefile pour que sa variable
;; 'PREFIX' pointe vers « out ».
(let ((out (assoc-ref outputs "out")))
(substitute* "Makefile"
(("PREFIX =.*")
(string-append "PREFIX = "
out "\n")))))))))))
a year ago
User avatar None

Source string changed

  1. guix
  2. documentation-manual
  3. French
(define-public example
(package
(name "example")
;; other fields omitted
(build-system gnu-build-system)
(arguments
'(#:phases (list
#:phases
#~(modify-phases %standard-phases
(delete 'configure)
(add-before 'build 'set-prefix-in-makefile
(lambda* (#:key outinputs #:allow-other-keys)
;; Modify the makefile so that its
;; 'PREFIX' variable points to "out".
#$output and
 (let ((out (assoc-ref outputs "out")))
;; 'XMLLINT' points to the correct path.
 (substitute* "Makefile"
(("PREFIX =.*")
(string-append "PREFIX = " #$output "\n"))
(("XMLLINT =.*")
 (string-append "PREFIXXMLLINT = "
(search-input-file inputs "/bin/xmllint")
 out "\n")))))))))))
a year ago
Browse all string changes

Things to check

Mismatched \n

Number of \n literals in translation does not match source

Reset

Mismatching line breaks

Number of new lines in translation does not match source

Reset

Glossary

English French
input entrée guix Glossary
package paquet guix Glossary
substitute substitut guix Glossary

String information

Source string description
type: lisp
Flags
no-wrap
Source string location
guix-git/doc/guix.texi:10469
String age
a year ago
Last updated
22 hours ago
Source string age
a year ago
Translation file
po/doc/guix-manual.fr.po, string 3783