LilyPond: manual de utilización del programa: 1.2 Utilización desde la línea de órdenes

[ << Ejecutar LilyPond ]	[Arriba][Índice general][Índice][ ? ]			[ Actualizar ficheros con convert-ly >> ]
[ < Utilización normal ]		[ Subir : Ejecutar LilyPond ]	[ Invocar a LilyPond > ]

1.2 Utilización desde la línea de órdenes

Esta sección contiene información adicional sobre el uso de LilyPond en la línea de órdenes. Esta forma puede ser preferible para pasarle al programa algunas opciones adicionales. Además, existen algunos programas complementarios ‘de apoyo’ (como midi2ly) que sólo están disponibles en la línea de órdenes.

Al hablar de la ‘línea de órdenes’, nos referimos a la consola del sistema operativo. Los usuarios de Windows posiblemente estén más familiarizados con los términos ‘ventana de MS-DOS’ o ‘línea de comandos’; Los usuarios de MacOS X puede que estén más familiarizados con los términos ‘terminal’ o ‘consola’. Éstos podrían requerir algunas configuraciones adicionales y deberían consultar también el apartado MacOS X.

La descripción del uso de esta parte de los sistemas operativos se sale del ámbito de este manual; le rogamos que consulte otros documentos sobre este tema si no le resulta familiar la línea de órdenes.

[ << Ejecutar LilyPond ]	[Arriba][Índice general][Índice][ ? ]			[ Actualizar ficheros con convert-ly >> ]
[ < Utilización desde la línea de órdenes ]		[ Subir : Utilización desde la línea de órdenes ]	[ > ]

Invocar `lilypond`

El ejecutable lilypond se puede llamar desde la línea de órdenes de la siguiente manera:

lilypond [opción]… archivo…

Cuando se invoca con un nombre de archivo sin extensión, se prueba en primer lugar con la extensión ‘.ly’. Para leer la entrada desde stdin, utilice un guión (-) en sustitución de archivo.

Cuando se procesa ‘archivo.ly’, la salida resultante son los archivos ‘archivo.ps’ y ‘archivo.pdf’. Se pueden especificar varios archivos; cada uno de ellos se procesará de forma independiente¹.

Si ‘archivo.ly’ contiene más de un bloque \score, el resto de las partituras se obtendrán como salida en archivos numerados, empezando por ‘archivo-1.pdf’. además, el valor de output-suffix (sufijo de salida) se insertará entre el nombre base y el número. Un archivo de entrada que contenga

#(define output-suffix "violin")
\score { … }
#(define output-suffix "cello")
\score { … }

produce como salida base‘-violin.pdf’ y base‘-cello-1.pdf’.

[ << Ejecutar LilyPond ]	[Arriba][Índice general][Índice][ ? ]			[ Actualizar ficheros con convert-ly >> ]
[ < Invocar a LilyPond ]		[ Subir : Invocar a LilyPond ]	[ Opciones de LilyPond básicas de la línea de órdenes > ]

Uso de LilyPond con las posibilidades básicas del shell

Dado que LilyPond es una aplicación de consola, las posibilidades del ‘shell’ usado para la llamada a LilyPond también pueden aprovecharse.

Por ejemplo:

lilypond *.ly

procesa todos los archivos de LilyPond dentro del directorio actual.

También puede ser útil redireccionar la salida de consola (p.ej. hacia un archivo):

lilypond file.ly 1> salida_estandar.txt

lilypond file.ly 2> error_estandar.txt

lilypond file.ly &> todo.txt

Redirecciona la salida ‘normal’, solo los ‘errores’ o ‘todo’, respectivamente, hacia un archivo de texto. Consulte la documentación de su shell concreto, Command (Windows), las aplicaciones Terminal o Console (MacOS X) para ver si el redireccionamiento de la salida está contemplado o si la sintaxis es distinta.

El ejemplo siguiente busca y procesa todos los archivos de entradas que estén en el directorio actual y en todos los que están por debajo de él, recursivamente. Los archivos de salida se pondrán en el mismo directorio desde el que se ejecutó la instrucción, en lugar de aquellos en los que estaban los archivos de entrada originales.

find . -name '*.ly' -exec lilypond '{}' \;

También debe funcionar para los usarios de MacOS X.

Un usuario de Windows haría los siguiente:

forfiles /s /M *.ly /c "cmd /c lilypond @file"

introduciendo esstas instrucciones desde un indicador de órdenes que normalmente está en Inicio > Accessorios > Símbolo del sistema o para los usuarios de la versión 8, escribiendo en la ventana de búsqueda ‘indicador de órdenes’.

De forma alternativa, una ruta explícita al nivel superior de su carpeta que contenga todas las subcarpetas con archivos de entrada en su interior se puede especificat mediante la opción /p;

forfiles /s /p C:\Documentos\MisPartituras /M *.ly /c "cmd /c lilypond @file"

Si el nombre de la ruta del directorio de nivel superior contiene espacios, entonces es necesario incluir toda la ruta entre comillas:

forfiles /s /p "C:\Documentos\Mis Partituras" /M *.ly /c "cmd /c lilypond @file"

[ << Ejecutar LilyPond ]	[Arriba][Índice general][Índice][ ? ]			[ Actualizar ficheros con convert-ly >> ]
[ < ]		[ Subir : Utilización desde la línea de órdenes ]	[ Opciones avanzadas de línea de órdenes para LilyPond > ]

Opciones de LilyPond básicas de la línea de órdenes

Están contempladas las siguientes opciones:

-b, --bigpdfs

Los archivos PDF generados serán mucho más grandes de lo normal (a causa de la poca o ninguna optimización de las fuentes tipográficas). Sin embargo, si dos o más archivos PDF se incluyen dentro de pdftex, xetex o luatex los documentos producidos pueden procesarse después a través de ghostscript (mezclando los datos de tipografías duplicados) dando como resultado archivos PDF significativamente más pequeños.

lilypond -b archivo

Después, ejecute ghostscript;

gs -q -sDEVICE=pdfwrite -o gsout.pdf archivo.pdf

Se puede entonces usar pdfsizeopt.py para optimizar aún más el tamaño del archivo:

pdfsizeopt.py --use-multivalent=no gsout.pdf final.pdf

-d, --define-default=variable=valor

Véase Opciones avanzadas de línea de órdenes para LilyPond.

-e, --evaluate=expresión

Evaluar la expresión de Scheme antes de analizar los archivos ‘.ly’. Se pueden pasar varias opciones ‘-e’, que se evaluarán en secuencia.

La expresión se evaluará en el módulo guile-user, de manera que si quiere usar definiciones dentro de expresión, debe utilizar

lilypond -e '(define-public a 42)'

en la línea de órdenes, e incluir

#(use-modules (guile-user))

al principio del archivo ‘.ly’.

Nota: Los usuarios de Windows deben utilizar comillas dobles en lugar de apóstrofos simples.

-f, --format=format

which formats should be written. Choices for format are ps, pdf, and png.

Example: lilypond -fpng filename.ly

Para los formatos svg y eps utilice la opción -dbackend. Véase Opciones avanzadas de línea de órdenes para LilyPond.

-h, --help

Mostrar un resumen de las formas de utilización.

-H, --header=CAMPO

Volcar un campo de cabecera al archivo ‘NOMBREBASE.CAMPO’

-i, --init=archivo

Establecer el archivo de inicio a archivo (predeterminado: ‘init.ly’).

-I, --include=directorio

Añadir el directorio a la ruta de búsqueda de archivos de entrada.

Se pueden escribir varias opciones -I. La búsqueda se inicia en el primer directorio definido, y si el archivo que se debe incluir no se encuentra, la búsqueda continúa en los directorios siguientes.

-j, --jail=usuario,grupo,jaula,directorio

Ejecutar lilypond en una jaula de chroot.

La opción ‘--jail’ (jaula) proporciona una alternativa más flexible a la opción ‘-dsafe’ cuando el proceso de tipografía de LilyPond está disponible a través de un servidor web o cuando LilyPond ejecuta instrucciones enviadas por fuentes externas (véase Opciones avanzadas de línea de órdenes para LilyPond).

La opción ‘--jail’ funciona cambiando la raíz de lilypond a jaula justo antes de comenzar el proceso de compilación en sí. Entonces se cambian el usuario y el grupo a los que se han dado en la opción, y el directorio actual se cambia a directorio. Esta instalación garantiza que no es posible, al menos en teoría, escapar de la jaula. Observe que para que funcione ‘--jail’, se debe ejecutar lilypond como root, lo que normalmente se puede hacer de una forma segura utilizando sudo.

La instalación de una jaula puede ser un asunto relativamente complejo, pues debemos asegurarnos de que LilyPond puede encontrar dentro de la propia jaula todo lo que necesita para poder compilar la fuente. Una típica configuración de jaula de chroot consta de los siguientes elementos:

Preparar un sistema de archivos separado

Se debe crear un sistema de archivos separado para LilyPond, de forma que se pueda montar con opciones seguras como noexec, nodev y nosuid. De esta forma, es imposible ejecutar programas o escribir directamente a un dispositivo desde LilyPond. Si no quiere crear una partición separada, tan sólo tiene que crear un archivo de un tamaño razonable y usarlo para montar un dispositivo loop. El sistema de archivos separado garantiza también que LilyPond nunca pueda escribir en un espacio mayor del que se le permita.

Preparar un usuario separado

Se debe usar un usuario y grupo separados (digamos lily/lily) con bajos privilegios para ejecutar LilyPond dentro de la jaula. Debería existir un solo directorio con permisos de escritura para este usuario, y debe pasarse en el valor directorio.

Preparar la jaula

LilyPond necesita leer algunos archivos mientras se ejecuta. Todos estos archivos se deben copiar dentro de la jaula, bajo la misma ruta en que aparecen en el sistema de archivos real de root. Todo el contenido de la instalación de LilyPond (por ejemplo ‘/usr/share/lilypond’) se debe copiar.

Si surgen problemas, la forma más sencilla de rastrearlos es ejecutar LilyPond usando strace, lo que le permitirá determinar qué archivos faltan.

Ejecutar LilyPond

Dentro de una jaula montada con noexec es imposible ejecutar ningún programa externo. Por tanto, LilyPond se debe ejecutar con un backend que no necesite tal programa. Como ya hemos mencionado, se debe ejecutar con privilegios del superusuario (que por supuesto perderá inmediatamente), posiblemente usando sudo. También es una práctica recomendable limitar el número de segundos de tiempo de CPU que LilyPond puede usar (p.ej., usando ulimit -t), y, si su sistema operativo lo contempla, el tamaño de la memoria que se puede reservar. Véase también LilyPond en una jaula de chroot.

-l, --loglevel=LEVEL

Fijar el grado en que la salida de consola es prolija al nivel LEVEL. Los valores posibles son:

NONE: Ninguna salida en absoluto, ni siquiera mensajes de error.
ERROR: Solamente mensajes de error, no advertencias o indicaciones de progreso.
WARN: Advertencias y mensajes de error, no de progreso.
BASIC_PROGRESS: Mensajes de progreso básicos (éxito), advertencias y errores.
PROGRESS: Todos los mensajes de progreso, advertencias y errores.
INFO (predeterminado): Mensajes de progreso, advertencias, errores e información de ejecución adicional.
DEBUG: Todos los mensajes posibles, incuida la información de depuración prolija.

-o, --output=ARCHIVO o CARPETA

Establecer el nombre del archivo de salida predeterminado a ARCHIVO o, si existe una carpeta con ese nombre, dirigir la salida hacia CARPETA, tomando el nombre de archivo del documento de entrada. Se añade el sufijo correspondiente (por ejemplo, .pdf para PDF) en los dos casos.

--ps

Generar PostScript.

--png

Generar imágenes de las páginas en formato PNG. Esto implica ‘--ps’. La resolución en PPP de la imagen se puede establecer con

-dresolution=110

--pdf

Generar PDF. Implica ‘--ps’.

-v, --version

Mostrar la información de la versión.

-V, --verbose

Ser prolijo: mostrar las rutas completas de todos los archivos que se leen, y dar información cronométrica.

-w, --warranty

Mostrar la garantía con que viene GNU LilyPond (¡no viene con NINGUNA GARANTÍA!).

[ << Ejecutar LilyPond ]	[Arriba][Índice general][Índice][ ? ]			[ Actualizar ficheros con convert-ly >> ]
[ < Opciones de LilyPond básicas de la línea de órdenes ]		[ Subir : Utilización desde la línea de órdenes ]	[ Variables de entorno > ]

Opciones avanzadas de línea de órdenes para LilyPond

-d[option-name]=[value],

–define-default=[option-name]=[value] Establece la función de Scheme interna equivalente a valor. Por ejemplo:

-dbackend=svg

Si no se proporciona ningún valor, se usa el valor predeterminado. Para desactivar una opción se puede anteponer no- a la variable. Por ejemplo:

-dpoint-and-click=#f

is the same as

-dno-point-and-click

Están contempladas las siguientes opciones junto a sus respectivos valores predeterminados:

Símbolo	Valor	Explicación/Opciones
`anti-alias-factor` (factor de antialias)	`1`	Renderizar a mayor resolución (utilizando el factor dado) y reducir la escala del resultado para así evitar ‘escaleras’ en las imágenes `PNG`.
`aux-files` (archivos auxiliares)	`#t`	Crear archivos `.tex`, `.texi` y `.count` cuando se usa con la opción de ‘back-end’ `EPS`.
`backend`	`ps`	Es el ajuste predeterminado. Los archivos Postscript (la opción predeterminada) incluyen las fuentes tipográficas `TTF`, `Type1` y `OTF`. No se hace ningún subconjunto de estas fuentes. Tenga en cuenta que el uso de conjuntos de caracteres ‘orientales’ puede dar lugar a archivos muy grandes.
	`eps`	Usado como opción predeterminada por la instrucción `lilypond-book`. Vuelca cada página al mismo tiempo como un solo archivo con todas las ṕaginas y fuentes tipográficas incluidas y como archivos postscript separados para cada página pero sin las fuentes tipográficas incluidas.
	`null`	No producir ninguna partitura impresa a la salida; tiene el mismo efecto que `-dno-print-pages`.
	`scm`	Volcado de las instrucciones de dibujo internas basadas en Scheme, en bruto.
	`svg`	Gráficos vectoriales escalables. Por cada página de la salida, se crea un solo archivo `SVG`. Los glifos musicales se codifican como gráficos vectoriales, pero las fuentes tipográficas del texto no se incrustan en los archivos SVG. Cualquier visor de SVG necesita que las fuentes de texto correspondientes estén disponibles para la correcta representación tanto del texto como de la letra. Se recomienda no utilizar ‘alias’ ni ‘listas’ de fuentes tipográficas por si el visor de SVG no es capaz de manejarlas. Al usar archivos de fuente abierta para la web Web Open Font Format (WOFF), es necesario indicar la opción `--svg-woff`.

Nota para el backend de salida svg: En la salida SVG, LilyPond usa por defecto los valores de font-family genéricos serif, sans-serif, o monospace. Por tanto, al usar el backend svg debemos definir explícitamente las fuentes predeterminadas deseadas en el archivo de entrada:

\paper  {
  #(define fonts
    (make-pango-font-tree "TeX Gyre Schola"
                          "TeX Gyre Heros"
                          "TeX Gyre Cursor"
                          (/ staff-height pt 20)))
}

Véase también Fuentes tipográficas del documento completo.

`check-internal-types`	`#f`	Comprobar el tipo de cada asignación de propiedades.
`clip-systems` (recortar los sistemas)	`#f`	Extraer fragmentos de música de la partitura. Requiere que la función `clip-regions` esté definida dentro del bloque `\layout`. Véase Extracción de fragmentos de música. No se extrae ningún fragmento si se usa con la copción ‘`-dno-print-pages`’.
`datadir` (directorio de datos)		Prefijo de los archivos de datos (sólo lectura).
`debug-gc`	`#f`	Volcar estadísticas de depuración de memoria.
`debug-gc-assert-parsed-dead`	`#f`	Para la depuración de memoria: asegurarse de que todas las referencias a objetos analizados están muertas. Es una opción interna, y se activa automáticamente para `-ddebug-gc'.
`debug-lexer`	`#f`	Depuración del analizador léxico flex.
`debug-page-breaking-scoring`	`#f`	Volcar las partituras para muchas configuraciones de saltos de página diferentes.
`debug-parser`	`#f`	Depuración del analizador sintáctico bison.
`debug-property-callbacks`	`#f`	Depuración de las cadenas cíclicas de funciones de callback.
`debug-skylines`	`#f`	Depuración de las líneas de horizonte.
`delete-intermediate-files`	`#t`	Eliminar los archivos intermedios `.ps` inútiles ques e crean durante la compilación.
`dump-cpu-profile`	`#f`	Volcar información de cuenta de tiempo (dependiente del sistema).
`dump-profile`	`#f`	Volcar de la información de memoria y de tiempo para cada archivo.
`dump-signatures`	`#f`	Volcar las firmas de salida de cada sistema. Usado para las pruebas de regresión.
`embed-source-code`	`#f`	Empotrar los archivos de entrada en código de LilyPond dentro del documento PDF generado.
`eps-box-padding`	`#f`	Rellenar el borde izquierdo de la caja contenedora del EPS de salida en la cantidad dada (en mm).
`font-export-dir`	`#f [dir]`	Directorio para exportar las fuentes como archivos de Postscript.
`gs-load-fonts`	`#f`	Cargar las fuentes tipográficas a través de Ghostscript.
`gs-load-lily-fonts`	`#f`	Cargar sólo las fuentes de LilyPond por medio de Ghostscript.
`gs-never-embed-fonts`	`#f`	Hacer que Ghostscript incruste solo las fuentes TrueType y no cualquier otro formato de fuente.
`gui`	`#f`	Se ejecuta silenciosamente y se redirige toda la salida a un archivo de registro.

Nota para los usuarios de Windows: De manera predeterminada, lilypond.exe dirige toda la salida de la información de avance hacia la ventana de consola, lilypond-windows.exe no lo hace y devuelve un indicador del sistema, sin ninguna indicación del avance, inmediatamente en la línea de órdenes. La opción ‘-dgui’ se puede usar en este caso para redirigir la salida a un archivo de registro.

`help`	`#f`	Mostrar esta ayuda.
`include-book-title-preview`	`#t`	Incluir los títulos de libro en las imágenes de vista previa.
`include-eps-fonts`	`#t`	Incluir las fuentes tipográficas en los archivos EPS de cada uno de los sistemas.
`include-settings`	`#f`	Incluir el archivo de los ajustes globales, se incluye antes de que la partitura se procese.
`job-count`	`#f`	Procesar en paralelo, usando el número de tareas dado.
`log-file`	`#f [file]`	Si se da una cadena `NOMBRE` como segundo argumento, redirigir la salida al archivo de registro `NOMBRE.log`.
`max-markup-depth`	`1024`	Profundidad máxima del árbol de marcado. Si un marcado tiene más niveles, suponer que no terminará por sí mismo, imprimiento una advertencia y devolviendo en su lugar un elemento de marcado nulo.
`midi-extension`	`"midi"`	Fijar la extensión de archivo predeterminada para el archivo de salida MIDI a la cadena dada.
`music-strings-to-paths`	`#f`	Convertir las cadenas de texto a rutas cuando los glifos pertenecen a una fuente de tipografía musical.
`paper-size`	`\"a4\"`	Establecer el tamaño predeterminado del papel. Observe que la cadena debe ir encerrada entre comillas dobles.
`pixmap-format`	`png16m`	Fijar el formato de salida de Ghostscript para las imágenes de píxeles.
`point-and-click`	`#t`	Añadir enlaces de ‘apuntar y pulsar’ a la salida PDF y SVG. Véase Apuntar y pulsar.
`preview`	`#f`	Crear imágenes de vista previa además de la salida normal.

Esta opción está contemplada por todos los ‘back-ends’: pdf, png, ps, eps y svg, pero no por scm. Genera un archivo de salida, en la forma miArchivo.preview.extensión, que contiene los títulos y el primer sistema de la música. Si se están utilizando bloques \book o \bookpart, aparecen en la salida los títulos de \book, \bookpart o \score, incluido el primer sistema de cada bloque \score si la variable de \paper print-all-headers está fijada al valor #t.

Para suprimir la salida usual, utilice las opciones ‘-dprint-pages’ o ‘-dno-print-pages’ según sus necesidades.

`print-pages`	`#t`	Generar páginas completas (es la opción predeterminada). Es útil ‘`-dno-print-pages`’ en combinación con ‘`-dpreview`’.
`profile-property-accesses`	`#f`	Conservar las estadísticas de las llamadas de función `get_property()`.
`protected-scheme-parsing`	`#t`	Continuar cuando se captan en el analizador sintáctico errores del Scheme empotrado. Si se fija a `#f`, detenerse cuando haya errores e imprimir un registro de traza de pila.
`read-file-list`	`#f [archivo]`	Especificar el nobmre de un archivo que contiene una lista de archivos de entrada para procesar.
`relative-includes`	`#f`	Cuando se procesa una instrucción `\include` command, buscar el archivo incluido de forma relativa al archivo actual (en lugar del archivo principal).
`resolution`	`101`	Fijar la resolución para generar imágenes de píxeles `PNG` al valor dado (en ppp).
`safe`	`#f`	No confiar en la entrada `.ly`.

Cuando el servicio de tipografía está disponible a través de un servidor web, SE DEBEN pasar las opciones ‘--safe’ o ‘--jail’. La opción ‘--safe’ evita que el código de Scheme monte un desastre, p.ej.:

#(s ystem "rm -rf /")  % demasiado peligroso para escribirlo correctamente
{
  c4^$(ly:gulp-file "/etc/passwd") % malicioso aunque no tan destructivo
}

La opción ‘-dsafe’ funciona evaluando las expresiones de Scheme en línea dentro de un módulo seguro especial. Deriva del módulo ‘safe-r5rs’ de GUILE, pero además añade unas cuantas funciones de la API de LIlyPond que están relacionadas en ‘scm/safe-lily.scm’.

Además, el modo seguro prohíbe las directivas \include y desactiva la utilización de barras invertidas en las cadenas de TeX. Asimismo, no es posible importar variables de LilyPond dentro de Scheme cuando se está en modo seguro.

‘-dsafe’ no detecta la sobreutilización de recursos, por lo que aún es posible hacer que el programa se cuelgue indefinidamente, por ejemplo suministrando estructuras de datos cíclicas en el backend. Por ello, si está usando LilyPond en un servidor web accesible públicamente, el proceso se debe limitar tanto en el uso de memoria como de CPU.

El modo seguro evita que se puedan compilar muchos fragmentos de código útiles.

La opción ‘--jail’ es una alternativa más segura aún, pero requiere más trabajo para su configuración. Véase Opciones de LilyPond básicas de la línea de órdenes.

`separate-log-files`	`#f`	Para los archivos de entrada `ARCHIVO1.ly`, `ARCHIVO2.ly`, etc. sacar los datos de registro hacia los archivos `ARCHIVO1.log`, `ARCHIVO2.log`…
`show-available-fonts`	`#f`	Listar todos los nombres de las fuentes tipográficas disponibles.
`strict-infinity-checking`	`#f`	Forzar una terminación abrupta si se encuentran las excepciones de punto flotante `Inf` y `NaN`.
`strip-output-dir`	`#t`	No usar los directorios de los archivos de entrada al construir los nombres de los archivos de salida.
`strokeadjust`	`#f`	Forzar el ajuste de los trazos de PostScript. Esta opción es relevante principalmente cuando se genera un PDF a partir de la salida de PostScript (el ajuste del trazo está por lo general activado automáticamente para dispositivos de mapa de puntos de baja resolución). Sin esta opción, los visores de PDF tienden a producir anchuras de plica muy poco consistentes a las resoluciones típicas de las pantallas de ordenador. La opción no afecta de forma muy significativa a la calidad de la impresión y causa grandes incrementos en el tamaño del archivo PDF.
`svg-woff`	`#f`	Esta opción es necesaria al usar archivos de fuente abierta para la Web, Web Open Font Format (WOFF) con la instrucción de backend `svg`. Se crea un solo archivo SVG para cada página de salida. Aparte de los glifos musicales propios de LilyPond, no se incluye ninguna otra información de fuente tipográfica. Todo visor de SVG necesita, por ello, tener las fuentes disponibles para la representación correcta tanto del texto como de la letra. Asimismo se recomienda no usar alias de fuentes ni listas, por si el visor de SVG no es capaz de manejarlos.
`trace-memory-frequency`	`#f`	Registrar el uso de células de Scheme esta cantidad de veces por segundo. Volcar los resultados en `ARCHIVO.stacks` y en `ARCHIVO.graph`.
`trace-scheme-coverage`	`#f`	Registrar la cobertura de los archivos de Scheme en `ARCHIVO.cov`.
`verbose`	`#f`	Salida prolija, es decir el nivel de registro en DEBUG (sólo lectura).
`warning-as-error`	`#f`	Cambiar todos los mensajes de advertencia y de ‘error de programación’ a errores.

[ << Ejecutar LilyPond ]	[Arriba][Índice general][Índice][ ? ]			[ Actualizar ficheros con convert-ly >> ]
[ < Opciones avanzadas de línea de órdenes para LilyPond ]		[ Subir : Utilización desde la línea de órdenes ]	[ LilyPond en una jaula de chroot > ]

Variables de entorno

lilypond reconoce las siguientes variables de entorno:

LILYPOND_DATADIR: Especifica un directorio en el que los mensajes de localización y de datos se buscarán de forma predeterminada. El directorio debe contener subdirectorios llamados ‘ly/’, ‘ps/’, ‘tex/’, etc.
LANG: Selecciona el idioma de los mensajes de advertencia.
LILYPOND_LOGLEVEL: Nivel de registro predeterminado. Si LilyPond se llama sin ningún nivel de registro explícito (es decir, sin opción de línea de órdenes ‘--loglevel’), se usa este valor.
LILYPOND_GC_YIELD: Una variable, como porcentaje, que ajusta el comportamiento de la administración de memoria. Con valores más altos, el programa usa más memoria; con valores más bajos, usa más tiempo de CPU. El valor predeterminado es 70.

[ << Ejecutar LilyPond ]	[Arriba][Índice general][Índice][ ? ]			[ Actualizar ficheros con convert-ly >> ]
[ < Variables de entorno ]		[ Subir : Utilización desde la línea de órdenes ]	[ Mensajes de error > ]

LilyPond en una jaula de chroot

La preparación del servidor para que ejecute LilyPond en una jaula de chroot es una tarea muy complicada. Los pasos están relacionados más abajo. Los ejemplos que aparecen en cada uno de los pasos son válidos para Ubuntu GNU/Linux, y pueden requerir el uso de sudo según corresponda.

Instale los paquetes necesarios: LilyPond, Ghostscript e ImageMagick.
Cree un usuario nuevo con el nombre de lily:
```
adduser lily
```
Esto también creará un nuevo grupo para el usuario lily, y una carpeta personal, /home/lily
En la carpeta personal del usuario lily, cree un archivo para usarlo como un sistema de archivos separado:
```
dd if=/dev/zero of=/home/lily/loopfile bs=1k count= 200000
```
Este ejemplo crea un archivo de 200MB para su uso como el sistema de archivos de la jaula.

Cree un dispositivo loop, haga un sistema de archivos y móntelo, después cree una carpeta que sea escribible por el usuario lily:

mkdir /mnt/lilyloop
losetup /dev/loop0 /home/lily/loopfile
mkfs -t ext3 /dev/loop0 200000
mount -t ext3 /dev/loop0 /mnt/lilyloop
mkdir /mnt/lilyloop/lilyhome
chown lily /mnt/lilyloop/lilyhome

En la configuración de los servidores, JAIL será /mnt/lilyloop y DIR será /lilyhome.

Cree un gran árbol de directorios dentro de la jaula copiando los archivos necesarios, como se muestra en el guión de ejemplo que aparece más abajo.

Puede usar sed para crear los archivos de copia necesarios para un ejecutable dado:

for i in "/usr/local/lilypond/usr/bin/lilypond" "/bin/sh" "/usr/bin/;  \
  do ldd $i | sed 's/.*=> \/\(.*\/\)\([^(]*\).*/mkdir -p \1 \&\&  \
    cp -L \/\1\2 \1\2/' | sed 's/\t\/\(.*\/\)\(.*\) (.*)$/mkdir -p  \
      \1 \&\& cp -L \/\1\2 \1\2/' | sed '/.*=>.*/d'; done

Guión de ejemplo para Ubuntu 8.04 de 32 bits

#!/bin/sh
## aquí se fijan los valores predeterminados

username=lily
home=/home
loopdevice=/dev/loop0
jaildir=/mnt/lilyloop
# prefijo (¡sin la barra inicial!)
lilyprefix=usr/local
# el directorio en que lilypond se encuentra instalado en el sistema
lilydir=/$lilyprefix/lilypond/

userhome=$home/$username
loopfile=$userhome/loopfile
adduser $username
dd if=/dev/zero of=$loopfile bs=1k count=200000
mkdir $jaildir
losetup $loopdevice $loopfile
mkfs -t ext3 $loopdevice 200000
mount -t ext3 $loopdevice $jaildir
mkdir $jaildir/lilyhome
chown $username $jaildir/lilyhome
cd $jaildir

mkdir -p bin usr/bin usr/share usr/lib usr/share/fonts $lilyprefix tmp
chmod a+w tmp

cp -r -L $lilydir $lilyprefix
cp -L /bin/sh /bin/rm bin
cp -L /usr/bin/convert /usr/bin/gs usr/bin
cp -L /usr/share/fonts/truetype usr/share/fonts

# Ahora la magia de copiar las bibliotecas
for i in "$lilydir/usr/bin/lilypond" "$lilydir/usr/bin/guile" "/bin/sh"  \
  "/bin/rm" "/usr/bin/gs" "/usr/bin/convert"; do ldd $i | sed 's/.*=>  \
    \/\(.*\/\)\([^(]*\).*/mkdir -p \1 \&\& cp -L \/\1\2 \1\2/' | sed  \
      's/\t\/\(.*\/\)\(.*\) (.*)$/mkdir -p \1 \&\& cp -L \/\1\2 \1\2/'  \
        | sed '/.*=>.*/d'; done | sh -s

# Los archivos compartidos para ghostscript...
      cp -L -r /usr/share/ghostscript usr/share
# Los archivos compartidos para ImageMagick
      cp -L -r /usr/lib/ImageMagick* usr/lib

### Ahora, suponiendo que tenemos test.ly en /mnt/lilyloop/lilyhome,
### deberíamos poder ejecutar:
### Observe que /$lilyprefix/bin/lilypond es un guión, que establece
### un valor para LD_LIBRARY_PATH : esto es crucial
      /$lilyprefix/bin/lilypond -jlily,lily,/mnt/lilyloop,/lilyhome test.ly

Notas el pie

[1] El estado de GUILE no se restablece después de procesar un archivo .ly, por lo que debe tener cuidado de no modificar ningún valor predeterminado desde dentro de Scheme.

[ << Ejecutar LilyPond ]	[Arriba][Índice general][Índice][ ? ]			[ Actualizar ficheros con convert-ly >> ]
[ < Variables de entorno ]		[ Subir : Utilización desde la línea de órdenes ]	[ Mensajes de error > ]

Otros idiomas: English, català, deutsch, français, magyar, italiano, 日本語.
Acerca de la selección automática del idioma.

Invocar `lilypond`
Opciones de LilyPond básicas de la línea de órdenes
Opciones avanzadas de línea de órdenes para LilyPond
Variables de entorno
LilyPond en una jaula de chroot