LilyPond: manuale d'uso del programma: 1.2 Uso da linea di comando

[ << Eseguire lilypond ]	[Inizio][Contenuti][Indice][ ? ]			[ Aggiornare i file con convert-ly >> ]
[ < Uso normale ]		[ Su : Eseguire lilypond ]	[ Utilizzo di LilyPond > ]

1.2 Uso da linea di comando

Questa sezione contiene informazioni aggiuntive sull’uso di LilyPond da linea di comando. Questo può essere utile per assegnare opzioni aggiuntive al programma. Inoltre, ci sono alcuni programmi complementari di ‘aiuto’ (come midi2ly) che funzionano solo da linea di comando.

Con ‘linea di comando’ si intende la linea di comando del sistema operativo. Gli utenti Windows avranno più familiarità con i termini ‘shell DOS’ o ‘shell dei comandi’. Gli utenti MacOS X avranno più familiarità con i termini ‘terminale’ o ‘console’. Una configurazione ulteriore è necessaria per gli utenti MacOS X; si veda MacOS X.

Descrivere come usare questa parte di un sistema operativo non rientra negli obiettivi di questo manuale; si prega di consultare altra documentazione su questo argomento se non si conosce la linea di comando.

[ << Eseguire lilypond ]	[Inizio][Contenuti][Indice][ ? ]			[ Aggiornare i file con convert-ly >> ]
[ < Uso da linea di comando ]		[ Su : Uso da linea di comando ]	[ > ]

Utilizzo di `lilypond`

L’eseguibile lilypond può essere lanciato dalla linea di comando nel seguente modo.

lilypond [opzione]… file…

Se invocato con un nome di file senza estensione, viene tentata per prima l’estensione ‘.ly’. Per leggere l’input da stdin, usare un trattino (-) al posto di file.

Quando ‘file.ly’ viene elaborato, lilypond creerà ‘file.ps’ e ‘file.pdf’ come output. Possono essere specificati molti file; ognuno di essi sarà elaborato in modo indipendente. ¹

Se ‘file.ly’ contiene più di un blocco \book, allora tutte le altre partiture verranno salvate in file numerati, a partire da ‘file-1.pdf’. Inoltre, il valore di output-suffix (suffisso di output) sarà inserito tra la base del nome del file e il numero. Un file di input che contiene

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

produrrà come output base‘-violin.pdf’ e base‘-cello-1.pdf’.

[ << Eseguire lilypond ]	[Inizio][Contenuti][Indice][ ? ]			[ Aggiornare i file con convert-ly >> ]
[ < Utilizzo di LilyPond ]		[ Su : Utilizzo di LilyPond ]	[ Opzioni di base della linea di comando per LilyPond > ]

Usare LilyPond con funzionalità standard della shell

Dato che LilyPond è un’applicazione a linea di comando, si possono sfruttare le funzionalità della ‘shell’ usata per lanciare LilyPond.

Per esempio:

lilypond *.ly

elaborerà tutti i file LilyPond nella directory corrente.

Potrebbe essere utile anche redirigere l’output della console (per esempio in un file):

lilypond file.ly 1> stdout.txt

lilypond file.ly 2> stderr.txt

lilypond file.ly &> all.txt

Questi tre comandi redirigono rispettivamente l’output ‘normale’, gli ‘errori’ o ‘tutto’ in un file di testo. Consulta la documentazione della tua shell, del prompt dei comandi (Windows), delle applicazioni Terminale o Console (MacOS X), per vedere se la redirezione dell’output è supportata o se la sintassi è diversa.

L’esempio seguente cerca e elabora tutti i file di input nella directory corrente e in tutte le directory inferiori ricorsivamente. I file di output saranno salvati nella stessa directory in cui è stato lanciato il comando, invece delle stesse directory in cui si trovano i file di input.

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

Questo comando dovrebbe funzionare anche in MacOS X.

Gli utenti Windows devono lanciare questo comando:

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

nel prompt dei comandi, che di solito si trova in Avvio > Accessori > Prompt dei comandi, oppure, se si usa la versione 8, scrivendo ‘prompt dei comandi’ nella finestra di ricerca.

Altrimenti, si può indicare un percorso esplicito alla cartella che contiene tutte le sottocartelle con i file di input tramite l’opzione /p:

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

Tale percorso, se contiene spazi, deve essere racchiuso tra virgolette doppie:

forfiles /s /p "C:\Documents\My Scores" /M *.ly /c "cmd /c lilypond @file"

[ << Eseguire lilypond ]	[Inizio][Contenuti][Indice][ ? ]			[ Aggiornare i file con convert-ly >> ]
[ < ]		[ Su : Uso da linea di comando ]	[ Opzioni avanzate della linea di comando per LilyPond > ]

Opzioni di base della linea di comando per LilyPond

Sono contemplate le seguenti opzioni:

-b, --bigpdfs

I file PDF generati saranno molto più grandi del normale (a causa di un’ottimizzazione dei tipi di carattere scarsa o assente). Tuttavia, due o più file PDF, se inclusi in documenti pdftex, xetex o luatex, possono essere ulteriormente elaborati attraverso ghostscript (rimuovendo le duplicazioni dei dati dei tipi di carattere), ottenendo così file PDF molto più piccoli.

lilypond -b myfile

Poi eseguire ghostscript;

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

Poi si può usare pdfsizeopt.py per ottimizzare ulteriormente la dimensione del file;

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

-d, --define-default=variabile=valore

Si veda Opzioni avanzate della linea di comando per lilypond.

-e, --evaluate=espressione

Valuta l’espressione di Scheme prima di analizzare qualsiasi file ‘.ly’. Si possono specificare varie opzioni ‘-e’; saranno analizzate in modo sequenziale.

L’espressione sarà analizzata nel modulo guile-user, dunque se vuoi usare delle definizioni in espressione, usa

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

nella linea di comando, e includi

#(use-modules (guile-user))

in cima al file .ly.

Nota: Gli utenti Windows devono usare i doppi apici invece dei singoli apici.

-f, --format=formato

Formati di output. Come formato si può scegliere tra ps, pdf e png.

Esempio: lilypond -fpng file.ly

Per i formati svg e eps usare l’opzione -dbackend. Vedi Opzioni avanzate della linea di comando per lilypond.

-h, --help

Mostra una sintesi dell’utilizzo.

-H, --header=CAMPO

Estrae un campo dell’intestazione nel file ‘NOME.CAMPO’.

-i, --init=file

Imposta il file di inizializzazione su file (predefinito: ‘init.ly’).

-I, --include=directory

È possibile assegnare più opzioni -I. La ricerca inizierà nella prima Aggiunge directory al percorso di ricerca per i file di input. directory definita, e se il file da includere non viene trovato la ricerca continuerà nelle directory seguenti.

-j, --jail=utente,gruppo,gabbia,directory

Esegue lilypond in una gabbia chroot.

L’opzione ‘--jail’ fornisce un’alternativa più flessibile a ‘--safe’ quando la formattazione di LilyPond è messa a disposizione attraverso un server web o quando LilyPond esegue sorgenti provenienti dall’esterno (si veda Opzioni avanzate della linea di comando per lilypond).

L’opzione ‘--jail’ modifica la radice di lilypond in gabbia appena prima di iniziare il vero processo di compilazione. L’utente e il gruppo vengono poi modificati per corrispondere a quelli forniti, e la directory corrente viene spostata in directory. Questa configurazione garantisce che non sia possibile (almeno in teoria) uscire dalla gabbia. Si noti che perché ‘--jail’ funzioni lilypond deve essere eseguito come root; di solito questo si fa in modo sicuro col comando sudo.

Configurare una gabbia è una questione un po’ delicata, perché bisogna essere sicuri che LilyPond possa trovare tutto quello di cui ha bisogno per compilare il sorgente dentro la gabbia. Una configurazione tipica comprende i seguenti elementi:

Impostare un filesystem distinto

Si dovrebbe creare un filesystem separato LilyPond, così che possa essere montato con opzioni di sicurezza come noexec, nodev, e nosuid. In questo modo è impossibile lanciare degli eseguibili o scrivere su un dispositivo direttamente da LilyPond. Se non si vuole creare una partizione separata, si può creare un file di dimensioni ragionevoli e usarlo per montare un dispositivo di loop. Un filesystem separato garantisce inoltre che LilyPond non possa scrivere su uno spazio maggiore di quanto permesso.

Impostare un altro utente

Per eseguire LilyPond in una gabbia si dovrebbe usare un altro utente e gruppo (ad esempio, lily/lily) con pochi privilegi. Ci dovrebbe essere una sola directory scrivibile da questo utente, che dovrebbe essere passata in dir.

Preparare la gabbia

LilyPond ha bisogno di leggere alcuni file quando viene lanciato. Tutti questi file devono essere copiati nella gabbia, sotto lo stesso percorso in cui appaiono nel vero filesystem principale. Si deve copiare l’intero contenuto dell’installazione LilyPond (ad esempio, ‘/usr/share/lilypond’).

Se c’è un problema, il modo più semplice per individuarlo è lanciare LilyPond usando strace, che permetterà di scoprire quali file mancano.

Eseguire LilyPond

In una gabbia montata con noexec è impossibile eseguire qualsiasi programma esterno. Dunque LilyPond deve essere eseguito con un backend che non richieda tale programma. Come è già stato detto, deve essere eseguito con privilegi di superutente (che ovviamente perderà immediatamente), possibilmente con l’uso di sudo. È una buona idea limitare il numero di secondi di tempo della CPU che LilyPond può usare (ad esempio con ulimit -t), e, se il sistema operativo lo permette, la quantità di memoria che può essere allocata. Si veda anche LilyPond in una gabbia chroot.

-l, --loglevel=LIVELLO

Imposta la verbosità dell’output della console su LIVELLO. I valori possibili sono:

NONE: Nessun output, nemmeno i messaggi di errore.
ERROR: Solo i messaggi di errore, niente avvisi o messaggi di elaborazione.
WARN: Avvisi e messaggi di errore, nessun messaggio di elaborazione.
BASIC_PROGRESS: Messaggi di elaborazione di base (riuscita), avvisi e errori.
PROGRESS: Tutti i messaggi di elaborazione, avvisi e errori.
INFO (predefinito): Messaggi di elaborazione, avvisi, errori e ulteriori informazioni di esecuzione.
DEBUG: Tutti i messaggi possibili, incluso l’output verboso di debug.

-o, --output=FILE o CARTELLA

Imposta il file di output predefinito FILE oppure, se una cartella con quel nome esiste già, dirige l’output in CARTELLA, prendendo il nome del file dal file di input. In entrambi i casi verrà aggiunto il suffisso appropriato (ad esempio .pdf per il pdf).

--ps

Genera PostScript.

--png

Genera immagini di ogni pagina in formato PNG. Questo implica ‘--ps’. La risoluzione in DPI dell’immagine può essere impostata con

-dresolution=110

--pdf

Genera PDF. Questo implica ‘--ps’.

-v, --version

Mostra informazioni sulla versione.

-V, --verbose

Aumenta la prolissità: mostra i percorsi completi di tutti i file letti e dà informazioni sui tempi.

-w, --warranty

Mostra la garanzia con cui viene distribuito GNU LilyPond. (Distribuito con NESSUNA GARANZIA!)

[ << Eseguire lilypond ]	[Inizio][Contenuti][Indice][ ? ]			[ Aggiornare i file con convert-ly >> ]
[ < Opzioni di base della linea di comando per LilyPond ]		[ Su : Uso da linea di comando ]	[ Variabili d'ambiente > ]

Opzioni avanzate della linea di comando per `lilypond`

-d[nome-opzione]=[valore],

–define-default=[nome-opzione]=[valore] Imposta l’equivalente funzione interna di Scheme su valore. Per esempio:

-dbackend=svg

Se non viene specificato un valore, viene usato il valore predefinito. Per disabilitare un’opzione, si può usare il prefisso no- prima di nome-opzione. Per esempio:

-dpoint-and-click=#f

è equivalente a

-dno-point-and-click

Sono supportate le seguenti opzioni insieme ai loro rispettivi valori predefiniti:

Simbolo	Valore	Spiegazione/Opzioni
`anti-alias-factor`	`1`	Elabora a una risoluzione più alta (usando il fattore specificato) e ridimensiona il risultato per evitare gli ‘artefatti’ nelle immagini `PNG`.
`aux-files`	`#t`	Crea i file `.tex`, `.texi` e `.count` se usata con l’opzione del backend `eps`.
`backend`	`ps`	Questa è l’impostazione predefinita. I file Postscript (predefinito) includono i tipi di carattere `TTF`, `Type1` e `OTF`. Non vengono inclusi i “sottoinsiemi” di questi tipi. Se si usa un set di caratteri ‘orientali’, si possono ottenere file di grosse dimensioni.
	`eps`	Usata come opzione predefinita dal comando `lilypond-book`. Per ogni pagina crea sia un singolo file con tutte le pagine e i tipi di carattere inclusi sia file EPS (Encapsulated PostScript) separati per ogni pagina ma senza i tipi di caratteri inclusi.
	`null`	Non genera la stampa della partitura. Produce lo stesso effetto di `-dno-print-pages`.
	`scm`	Estrae i comandi di disegno grezzi e interni, basati su Scheme.
	`svg`	Scalable Vector Graphics. Viene creato un singolo file SVG per ogni pagina dell’output. I glifi musicali vengono tradotti in grafica vettoriale, ma i tipi di carattere del testo non sono incorporati nei file SVG. Dunque qualsiasi lettore SVG dovrà avere accesso ai tipi di carattere necessari per rendere in modo adeguato il testo. Si raccomanda di non usare ‘liste’ o ‘alias’ dei tipi di carattere se il lettore SVG non è in grado di gestirli. Se si usano i file Web Open Font Format (WOFF), è richiesta anche l’opzione `svg-woff`.

Nota per l’output del backend svg: Nell’output svg LilyPond usa i valori generici serif, sans-serif o monospace di font-family. Dunque quando si usa il backend svg è obbligatorio definire esplicitamente specifici tipi di carattere predefiniti nel proprio file di input:

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

Leggere anche Tipi di carattere per l'intero documento.

`check-internal-types`	`#f`	Controlla l’assegnazione di ogni proprietà per i tipi.
`clip-systems`	`#f`	Estrae frammenti musicali da una partitura. Per far ciò è necessario che sia stata definita la funzione `clip-regions` all’interno del blocco `\layout`. Maggiori informazioni in Estrarre frammenti musicali. Nessun frammento verrà estratto se questa opzione è usata insieme all’opzione ‘`-dno-print-pages`’.
`datadir`		Prefisso per i file di dati (sola lettura).
`debug-gc`	`#f`	Scarica le statistiche sul debug della memoria.
`debug-gc-assert-parsed-dead`	`#f`	Per il debug della memoria: Assicura che tutti i riferimenti agli oggetti analizzati siano eliminati. Questa è un’opzione interna e viene abilitata automaticamente da `-ddebug-gc'.
`debug-lexer`	`#f`	Debug dell’analizzatore lessicale flex.
`debug-page-breaking-scoring`	`#f`	Crea le partiture per diverse configurazioni di interruzione di pagina.
`debug-parser`	`#f`	Debug dell’analizzatore bison.
`debug-property-callbacks`	`#f`	Debug delle catene cicliche di callback.
`debug-skylines`	`#f`	Debug skylines.
`delete-intermediate-files`	`#t`	Cancella i file `.ps` intermedi e inutilizzabili creati durante la compilazione.
`dump-cpu-profile`	`#f`	Scarica l’informazione sui tempi (dipendente dal sistema).
`dump-profile`	`#f`	Scarica l’informazione sulla memoria e il tempo per ogni file.
`dump-signatures`	`#f`	Scarica le firme dell’output di ogni sistema. Usato per testare le regressioni.
`embed-source-code`	`#f`	Incorpora i file sorgente LilyPond nel documento PDF generato.
`eps-box-padding`	`#f`	Sposta il margine sinistro della cornice EPS dell’output della quantità specificata (in mm).
`font-export-dir`	`#f [dir]`	Directory per esportare i font come file PostScript.
`gs-load-fonts`	`#f`	Carica i font attraverso Ghostscript.
`gs-load-lily-fonts`	`#f`	Carica solo i font LilyPond attraverso Ghostscript.
`gs-never-embed-fonts`	`#f`	Fa sì che Ghostscript incorpori solo i font TrueType e nessun altro formato per font.
`gui`	`#f`	Esegue il programma senza stampare messaggi e redirige tutto l’output in un file di log.

Nota per gli utenti Windows: Per impostazione predefinita lilypond.exe stampa tutta l’informazione sull’avanzamento nella finestra dei comandi. lilypond-windows.exe non lo fa e riporta un prompt, privo di informazioni sull’avanzamento, subito nella linea di comando. L’opzione ‘-dgui’ può essere usata in questo caso per redirigere l’output in un file di log.

`help`	`#f`	Mostra questo aiuto.
`include-book-title-preview`	`#t`	Include i titoli dei libri nelle immagini di anteprima.
`include-eps-fonts`	`#t`	Include i font in file EPS con sistemi separati.
`include-settings`	`#f`	Include il file per le impostazioni globali, questo viene incluso prima che la partitura sia elaborata.
`job-count`	`#f`	Elabora in parallelo, usando il dato numero di lavori.
`log-file`	`#f [file]`	Se la stringa `FOO` viene assegnata come secondo argomento, redirige l’output nel file `FOO.log`.
`max-markup-depth`	`1024`	Massima profondità per la struttura del blocco markup. Se un blocco markup ha più livelli, assume che non terminerà da solo, stampa un avviso e restituisce al suo posto un markup vuoto.
`midi-extension`	`"midi"`	Imposta l’estensione predefinita per il file MIDI sulla stringa specificata.
`music-strings-to-paths`	`#f`	Converte le stringhe di testo in percorsi quando i glifi appartengono a un font musicale.
`paper-size`	`\"a4\"`	Imposta la dimensione predefinita del foglio. Nota che la stringa deve essere compresa tra virgolette precedute dal segno di escape.
`pixmap-format`	`png16m`	Imposta il formato di output di GhostScript per le immagini raster.
`point-and-click`	`#t`	Aggiunge i collegamenti ‘punta e clicca’ all’output PDF e SVG. Si veda Punta e clicca.
`preview`	`#f`	Crea immagini di anteprima oltre al normale output.

Questa opzione è supportata da tutti i backend; pdf, png, ps, eps e svg, ma non scm. Genera un file di output nella forma mioFile.preview.estensione, contenente i titoli e il primo sistema. Se vengono usati i blocchi \book o \bookpart, i titoli di \book, \bookpart o \score appariranno nell’output, incluso il primo sistema di ogni blocco \score se la variabile print-all-headers di \paper è impostata su #t.

Per impedire il normale output, si usano le opzioni ‘-dprint-pages’ o ‘-dno-print-pages’ in base alle proprie esigenze.

`print-pages`	`#t`	Genera le pagine complete (predefinito). ‘`-dno-print-pages`’ è utile in combinazione con ‘`-dpreview`’.
`profile-property-accesses`	`#f`	Mantiene una statistica delle chiamate di funzione `get_property()`.
`protected-scheme-parsing`	`#t`	Continua se l’analizzatore coglie degli errori nel codice scheme interno al file di input. Se impostato su `#f`, in caso di errore si ferma e mostra la traccia di stack.
`read-file-list`	`#f [file]`	Specifica il nome di un file che contiene una lista di file di input da elaborare.
`relative-includes`	`#f`	Quando elabora un comando `\include`, cerca il file incluso in posizione relativa al file corrente (invece che in posizione assoluta).
`resolution`	`101`	Imposta la risoluzione per generare immagini `PNG` su un certo valore (in dpi).
`safe`	`#f`	Non si fida dell’input nel file `.ly`.

Quando la formattazione di LilyPond viene messa a disposizione tramite un server web, si DEVE passare l’opzione ‘--safe’ o l’opzione ‘--jail’. L’opzione ‘--safe’ impedirà che il codice Scheme presente nell’input possa fare uno scempio, ad esempio

#(s ystem "rm -rf /")  % troppo pericoloso per scriverlo correttamente
{
  c4^$(ly:gulp-file "/etc/passwd") % malvagio ma non distruttivo
}

L’opzione ‘-dsafe’ serve a valutare le espressioni Scheme presenti nell’input in uno speciale modulo di sicurezza. Questo modulo di sicurezza è derivato dal modulo GUILE ‘safe-r5rs’, ma aggiunge alcune funzioni del LilyPond API. Queste funzioni sono elencate in ‘scm/safe-lily.scm’.

Inoltre, la modalità sicura non permette le direttive \include e disabilita l’uso del backslash nelle stringhe TeX. In modalità sicura, non è possibile importare le variabili di LilyPond in Scheme.

‘-dsafe’ non rileva il sovrautilizzo di risorse. È ancora possibile far sì che il programma rimanga in sospeso per un tempo indefinito, ad esempio alimentando il backend con strutture di dati cicliche. Dunque se si vuole usare LilyPond su un server web pubblicamente accessibile, si deve limitare il processo nell’uso della CPU e della memoria.

La modalità sicura bloccherà la compilazione di molti utili frammenti di codice LilyPond.

L’opzione ‘--jail’ è un’alternativa più sicura, ma richiede più lavoro per configurarla. Si veda Opzioni di base della linea di comando per LilyPond.

`separate-log-files`	`#f`	Per i file di input `FILE1.ly`, `FILE2.ly`, etc. salva i dati di log nei file `FILE1.log`, `FILE2.log`, …
`show-available-fonts`	`#f`	Elenca i nomi di font disponibili.
`strict-infinity-checking`	`#f`	Forza il blocco del programma quando si incontrano eccezioni `Inf` e `NaN` sui numeri in virgola mobile.
`strip-output-dir`	`#t`	Non usa le directory dei file di input per costruire i nomi dei file di output.
`strokeadjust`	`#f`	Forza l’aggiustamento del tratto da parte di PostScript. Questa opzione è utile quando il PDF è generato dall’output PostScript (l’aggiustamento del tratto di solito è abilitato automaticamente per gli strumenti bitmap a bassa risoluzione). Senza questa opzione, i lettori PDF tendono a produrre larghezze dei gambi molto variabili alle risoluzioni tipiche dei monitor. L’opzione non produce effetti visibili sulla qualità di stampa e causa un notevole aumento della dimensione dei file PDF.
`svg-woff`	`#f`	Questa opzione è richiesta se si usano i file del formato per font Web Open Font Format (WOFF) col backend SVG. Viene creato un singolo file SVG per ogni pagina di output. Eccetto i glifi musicali di LilyPond, nessun altro tipo di carattere verrà incorporato nel file. Dunque qualsiasi lettore SVG dovrà avere accesso ai tipi di carattere per rendere in modo adeguato il testo. Si raccomanda di non usare gli ‘alias’ o le ‘liste’ dei tipi di carattere se il lettore SVG non è in grado di gestirli.
`trace-memory-frequency`	`#f`	Registra molte volte al secondo l’uso delle celle da parte di Scheme. Salva i risultati in `FILE.stacks` e `FILE.graph`.
`trace-scheme-coverage`	`#f`	Registra la copertura dei file Scheme in `FILE.cov`.
`verbose`	`#f`	Output dettagliato, ovvero livello di log DEBUG (sola lettura).
`warning-as-error`	`#f`	Trasforma tutti i messaggi di avviso e di ‘errore di programmazione’ in errori.

[ << Eseguire lilypond ]	[Inizio][Contenuti][Indice][ ? ]			[ Aggiornare i file con convert-ly >> ]
[ < Opzioni avanzate della linea di comando per LilyPond ]		[ Su : Uso da linea di comando ]	[ LilyPond in una gabbia chroot > ]

Variabili d’ambiente

lilypond riconosce le seguenti variabili d’ambiente:

LILYPOND_DATADIR: Specifica la directory predefinita in cui saranno cercati i messaggi della localizzazione e i file di dati. Questa directory deve contenere sottodirectory chiamate ‘ly/’, ‘ps/’, ‘tex/’, etc.
LANG: Determina la lingua per i messaggi di avviso.
LILYPOND_LOGLEVEL: Il livello di log (loglevel) predefinito. Se LilyPond viene chiamato senza un livello di log esplicito (ovvero senza l’opzione ‘--loglevel’ della linea di comando), viene usato questo valore.
LILYPOND_GC_YIELD: Una variabile, in forma di percentuale, che regola il modo in cui viene gestita la memoria. Con valori più alti il programma usa più memoria, con valori più bassi usa più tempo della CPU. Il valore predefinito è 70.

[ << Eseguire lilypond ]	[Inizio][Contenuti][Indice][ ? ]			[ Aggiornare i file con convert-ly >> ]
[ < Variabili d'ambiente ]		[ Su : Uso da linea di comando ]	[ Messaggi di errore > ]

LilyPond in una gabbia chroot

Configurare un server perché esegua LilyPond in una gabbia chroot è un lavoro complesso. La procedura è spiegata sotto. Gli esempi si riferiscono a Ubuntu GNU/Linux e potrebbero richiedere l’uso di sudo in alcune situazioni.

Installa i pacchetti necessari: LilyPond, GhostScript e ImageMagick.
Crea un nuovo utente dal nome lily:
```
adduser lily
```
Questo comando creerà anche un nuovo gruppo per l’utente lily, e una cartella home, /home/lily
Nella cartella home dell’utente lily crea un file da usare come filesystem separato:
```
dd if=/dev/zero of=/home/lily/loopfile bs=1k count= 200000
```
In questo esempio è stato creato un file di 200MB da usare come filesystem della gabbia.

Crea un dispositivo di loop, crea e monta un filesystem, quindi crea una cartella scrivibile dall’utente 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

Nella configurazione dei server, JAIL sarà /mnt/lilyloop e DIR sarà /lilyhome.

Crea un grande albero delle directory nella gabbia copiando i file necessari, come mostrato nello script di esempio più in basso.

Puoi usare sed per creare i comandi di copia necessari per un certo eseguibile:

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

Script di esempio per Ubuntu 8.04 a 32-bit

#!/bin/sh
## defaults set here

username=lily
home=/home
loopdevice=/dev/loop0
jaildir=/mnt/lilyloop
# the prefix (without the leading slash!)
lilyprefix=usr/local
# the directory where lilypond is installed on the system
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

# Now the library copying magic
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

# The shared files for ghostscript...
      cp -L -r /usr/share/ghostscript usr/share
# The shared files for ImageMagick
      cp -L -r /usr/lib/ImageMagick* usr/lib

### Now, assuming that you have test.ly in /mnt/lilyloop/lilyhome,
### you should be able to run:
### Note that /$lilyprefix/bin/lilypond is a script, which sets the
### LD_LIBRARY_PATH - this is crucial
      /$lilyprefix/bin/lilypond -jlily,lily,/mnt/lilyloop,/lilyhome test.ly

Note a piè di pagina

[1] Lo status di GUILE non viene resettato dopo l’elaborazione di un file .ly: attenzione a non cambiare alcun valore predefinito dall’interno di Scheme.

[ << Eseguire lilypond ]	[Inizio][Contenuti][Indice][ ? ]			[ Aggiornare i file con convert-ly >> ]
[ < Variabili d'ambiente ]		[ Su : Uso da linea di comando ]	[ Messaggi di errore > ]

Altre lingue: English, català, deutsch, español, français, magyar, 日本語.
About automatic language selection.

Utilizzo di `lilypond`
Opzioni di base della linea di comando per LilyPond
Opzioni avanzate della linea di comando per `lilypond`
Variabili d’ambiente
LilyPond in una gabbia chroot