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 = "
out "\n"))(search-input-file inputs "/bin/xmllint")
#true "\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"))))))))))
777/8290 · 829

Sign in to save the translation.

English Spanish 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!}:
Por ejemplo, esta es la forma en la que @code{(guix build gnu-build-system)} define @code{%standard-phases}, la variable que contiene su lista asociativa de fases de construcción@footnote{Presentamos una visión simplificada de las fases de dichas construcción, ¡eche un vistazo al módulo @code{(guix build gnu-build-system)} para ver todos los detalles!}:
;; The build phases of 'gnu-build-system'.
;; Las fases de construcción 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)
;; Extracción del archivador tar de las fuentes.
(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)
;; Ejecución del guión 'configure'. Instalación de la salida
;; en "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)
;; Compilación.
(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)
;; Ejecución de la batería de pruebas.
(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)
;; Instalación de los archivos en el prefijo especificado
;; al guión '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 lista de las fases estándar (algunas se omiten por
;; brevedad). Cada elemento es un par símbolo/procedimiento.
(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.
Aquí se muestra como @code{%standard-phases} se define como una lista de pares símbolo/procedimiento (@pxref{Pairs,,, guile, GNU Guile Reference Manual}). El primer par asocia el procedimiento @code{unpack} con el símbolo @code{unpack}---un nombre; el segundo par define de manera similar la fase @code{configure}, etcétera. Cuando se construye un paquete que usa @code{gnu-build-system}, con su lista predeterminada de fases, estas fases se ejecutan de manera secuencial. Puede ver el nombre de cada fase a su inicio y tras su finalización en el registro de construcción de los paquetes que construya.
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}).
Echemos un vistazo a los propios procedimientos. Cada uno se define con @code{define*}: @code{#:key} enumera parámetros con palabras clave que el procedimiento acepta, con la posibilidad de proporcionar un valor predeterminado, y @code{#:allow-other-keys} especifica que se ignora cualquier otra palabra clave en los parámetros (@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.
El procedimiento @code{unpack} utiliza el valor proporcionado al parámetro @code{source}, usado por el sistema de construcción usa para proporcionar el nombre de archivo del archivador de fuentes (o la copia de trabajo del sistema de control de versiones), e ignora otros parámetros. La fase @code{configure} únicamente tiene en cuenta el parámetro @code{outputs}, una lista asociativa de nombres de salida de paquetes con su nombre de archivo en el almacén (@pxref{Packages with Multiple Outputs}). Para ello se extrae el nombre de archivo de @code{out}, la salida predeterminada, y se lo proporciona a la orden @command{./configure} como el prefijo de la instalación (@code{./configure --prefix=@var{out}}), lo que significa que @command{make install} acabará copiando todos los archivos en dicho directorio (@pxref{Configuration, configuration and makefile conventions,, standards, GNU Coding Standards}). Tanto @code{build} como @code{install} ignoran todos los parámetros. @code{check} utiliza el parámetro @code{test-target}, que especifica el nombre del objetivo del archivo Makefile que debe ejecutarse para ejecutar las pruebas; se imprime un mensaje y se omiten las pruebas cuando el parámetro @code{tests?} tiene falso como valor.
build phases, customizing
fases de construcción, personalización
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}}).
Se puede cambiar con el parámetro @code{#:phases} la lista de fases usada por el sistema de construcción para un paquete en particular. El cambio del conjunto de fases de construcción se realiza mediante la construcción de una nueva lista asociativa basada en la lista asociativa @code{%standard-phases} descrita previamente. Esto se puede llevar a cabo con procedimientos estándar para la manipulación de listas asociativas como @code{alist-delete} (@pxref{SRFI-1 Association Lists,,, guile, GNU Guile Reference Manual}); no obstante es más conveniente hacerlo con @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}:
Aquí se encuentra un ejemplo de una definición de paquete que borra la fase @code{configure} de @code{%standard-phases} e inserta una nueva fase antes de la fase @code{build}, llamada @code{proporciona-prefijo-en-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 ejemplo
(package
(name "ejemplo")
;; se omiten otros campos
(build-system gnu-build-system)
(arguments
'(#:phases (modify-phases %standard-phases
(delete 'configure)
(add-before 'build 'proporciona-prefijo-en-makefile
(lambda* (#:key outputs #:allow-other-keys)
;; Modifica el archivo de make para que la
;; variable 'PREFIX' apunte a "out".
(let ((out (assoc-ref outputs "out")))
(substitute* "Makefile"
(("PREFIX =.*")
(string-append "PREFIX = "
out "\n")))
#true))))))))
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 nueva fase insertada se escribe como un procedimiento anónimo, generado con @code{lambda*}; usa el parámetro @code{outputs} visto anteriormente. @xref{Build Utilities} para obtener más información sobre las funciones auxiliares usadas en esta fase y donde encontrará más ejemplos de uso 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
fases de evaluación, preparación de código para otras
staging, of code
preparación de código para otras fases de evaluación
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.
Tenga en cuenta que las fases de construcción son código que se evalúa cuando se realiza la construcción real del paquete. Esto explica por qué la expresión @code{modify-phases} al completo se encuentra escapada (viene precedida de @code{'}, un apóstrofe): se ha @dfn{preparado} para una ejecución posterior. @xref{G-Expressions} para obener una explicación sobre esta preparación del código para las distintas fases de ejecución y los distintos @dfn{estratos de código} implicados.
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.
En cuanto empiece a escribir definiciones de paquete no-triviales (@pxref{Defining Packages}) u otras acciones de construcción (@pxref{G-Expressions}), es probable que empiece a buscar funciones auxiliares parecidas a las habituales en el intérprete de ordenes---creación de directorios, borrado y copia recursiva de archivos, manipulación de fases de construcción, etcétera. El módulo @code{(guix build utils)} proporciona dichos procedimientos auxiliares.
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 mayoría de sistemas de construcción cargan @code{(guix build utils)} (@pxref{Build Systems}). Por tanto, cuando construya fases de construcción personalizadas para sus definiciones de paquetes, habitualmente puede asumir que dichos procedimientos ya han sido incorporados al ámbito de ejecución.
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}):
Cuando escriba G-expressions, puede importar @code{(guix build utils)} en el ``lado de la construcción'' mediante el uso @code{with-imported-modules} e importandolos al ámbito actual con la forma sintáctica @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)) ; Se importa.
(computed-file "empty-tree"
#~(begin
;; Se añade al ámbito actual.
(use-modules (guix build utils))
;; Happily use its 'mkdir-p' procedure.
(mkdir-p (string-append #$output "/a/b/c")))))
;; Se usa su procedimiento 'mkdir-p'.
(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)}.
El resto de esta sección es la referencia de la mayoría de las procedimientos de utilidad proporcionados por @code{(guix build utils)}.
Dealing with Store File Names
Tratamiento de nombres de archivo del almacén
This section documents procedures that deal with store file names.
Esta sección documenta procedimientos para el manejo de nombres de archivo del almacén.
{Procedure} %store-directory
{Procedimiento} %store-directory
Return the directory name of the store.
Devuelve el nombre del directorio del almacén.

Loading…

User avatar None

String updated in the repository

  1. guix
  2. documentation-manual
  3. Spanish
(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 ejemplo
(package
(name "ejemplo")
;; se omiten otros campos
(build-system gnu-build-system)
(arguments
'(#:phases (modify-phases %standard-phases
(delete 'configure)
(add-before 'build 'proporciona-prefijo-en-makefile
(lambda* (#:key outputs #:allow-other-keys)
;; Modifica el archivo de make para que la
;; variable 'PREFIX' apunte a "out".
(let ((out (assoc-ref outputs "out")))
(substitute* "Makefile"
(("PREFIX =.*")
(string-append "PREFIX = "
out "\n")))
#true))))))))
a year ago
User avatar None

Source string changed

  1. guix
  2. documentation-manual
  3. Spanish
(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 = "
out "\n"))(search-input-file inputs "/bin/xmllint")
#true "\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 Spanish
input guix Glossary
package guix Glossary
substitute guix Glossary

String information

Source string description
type: lisp
Flags
no-wrap
Source string location
guix-git/doc/guix.texi:10460
String age
a year ago
Last updated
yesterday
Source string age
a year ago
Translation file
po/doc/guix-manual.es.po, string 3786