Doc-it: update Notation and Usage manual

[lilypond.git] / Documentation / it / usage / running.itely

@c -*- coding: utf-8; mode: texinfo; documentlanguage: it -*-

@ignore
    Translation of GIT committish: 6ea18ce2f407ee754947a4fa18596bb38c8087f5

    When revising a translation, copy the HEAD committish of the
    version that you are working on.  For details, see the Contributors'
    Guide, node Updating translation committishes..
@end ignore

@c \version "2.17.6"


@node Eseguire lilypond
@chapter Eseguire @command{lilypond}
@translationof Running LilyPond

Questo capitolo descrive dettagliatamente gli aspetti tecnici dell'esecuzione
di LilyPond.

@menu
* Uso normale::
* Uso da linea di comando::
* Messaggi di errore::
* Errori comuni::
@end menu


@node Uso normale
@section Uso normale
@translationof Normal usage

La maggior parte degli utenti esegue LilyPond attraverso un'interfaccia grafica
(GUI); se non lo hai già fatto, leggi il @rlearning{Tutorial}.  Se usi un editor
diverso per scrivere i file lilypond, leggi la documentazione di quel programma.


@node Uso da linea di comando
@section Uso da linea di comando
@translationof Command-line usage

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 @q{aiuto} (come
@code{midi2ly}) che funzionano solo da linea di comando.

Con @q{linea di comando} si intende la linea di comando del sistema operativo.
Gli utenti Windows avranno più familiarità con i termini @q{shell DOS} o
@q{shell dei comandi}.  Gli utenti MacOS@tie{}X avranno più familiarità con i termini
@q{terminale} o @q{console}.  Una configurazione ulteriore è necessaria
per gli utenti MacOS@tie{}X; si veda @rweb{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.

@menu
* 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::
@end menu

@node Utilizzo di LilyPond
@unnumberedsubsec Utilizzo di @command{lilypond}
@translationof Invoking LilyPond

L'eseguibile @command{lilypond} può essere lanciato dalla linea di comando
nel seguente modo.

@example
lilypond [@var{opzione}]@dots{} @var{file}@dots{}
@end example


Se invocato con un nome di file senza estensione, viene tentata per prima
l'estensione @file{.ly}.  Per leggere l'input da stdin, usare un
trattino (@code{-}) al posto di @var{file}.

Quando @file{file.ly} viene elaborato, lilypond creerà @file{file.ps}
e @file{file.pdf} come output.  Possono essere specificati molti file;
ognuno di essi sarà elaborato in modo indipendente.  @footnote{Lo status di
GUILE non viene resettato dopo l'elaborazione di un file @code{.ly}:
attenzione a non cambiare alcun valore predefinito dall'interno di Scheme.}

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

@example
#(define output-suffix "violin")
\score @{ @dots{} @}
#(define output-suffix "cello")
\score @{ @dots{} @}
@end example

@noindent
produrrà come output @var{base}@file{-violin.pdf} e
@var{base}@file{-cello-1.pdf}.


@unnumberedsubsubsec Usare LilyPond con funzionalità standard della shell

Dato che LilyPond è un'applicazione a linea di comando, si possono sfruttare
le funzionalità della @q{shell} usata per lanciare LilyPond.

Per esempio:

@example
lilypond *.ly
@end example

@noindent
elaborerà tutti i file LilyPond nella directory corrente.

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

@example
lilypond file.ly 1> stdout.txt

lilypond file.ly 2> stderr.txt

lilypond file.ly &> all.txt
@end example

@noindent
Questi tre comandi redirigono rispettivamente l'output @q{normale}, gli
@q{errori} o @q{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.

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

@noindent
Questo comando dovrebbe funzionare anche in MacOS@tie{}X.

Gli utenti Windows devono lanciare questo comando:

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

@noindent
nel @code{prompt dei comandi}, che di solito si trova in
@code{Avvio > Accessori > Prompt dei comandi}, oppure, se si usa la
versione 8, scrivendo @q{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
@code{/p}:

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

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

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


@node Opzioni di base della linea di comando per LilyPond
@unnumberedsubsec Opzioni di base della linea di comando per LilyPond
@translationof Basic command line options for LilyPond

@cindex Utilizzo di @command{lilypond}
@cindex opzioni della linea di comando per @command{lilypond}
@cindex linea di comando, opzioni di
@cindex switch

Sono contemplate le seguenti opzioni:

@table @code

@item -b, --bigpdfs
@cindex 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 @w{@code{pdftex}},
@w{@code{xetex}} o @w{@code{luatex}}, possono essere ulteriormente
elaborati attraverso ghostscript (rimuovendo le duplicazioni dei dati
dei tipi di carattere), ottenendo così file PDF @emph{molto} più piccoli.

@example
lilypond -b myfile
@end example

Poi eseguire @code{ghostscript};

@example
gs -q -sDEVICE=pdfwrite -o gsout.pdf myfile.pdf
@end example

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

@example
pdfsizeopt.py --use-multivalent=no gsout.pdf final.pdf
@end example

@item -d, --define-default=@var{variabile}=@var{valore}
Si veda @ref{Advanced command line options for LilyPond}.

@cindex Scheme, valutazione dell'espressione
@cindex valutazione dell'espressione, Scheme

@item -e, --evaluate=@var{espressione}
Valuta l'@var{espressione} di Scheme prima di analizzare qualsiasi file @file{.ly}.
Si possono specificare varie opzioni @option{-e}; saranno analizzate in modo
sequenziale.

L'espressione sarà analizzata nel modulo @code{guile-user}, dunque se vuoi
usare delle definizioni in @var{espressione}, usa

@example
lilypond -e '(define-public a 42)'
@end example

@noindent
nella linea di comando, e includi

@example
#(use-modules (guile-user))
@end example

@noindent
in cima al file @code{.ly}.

@warning{Gli utenti Windows devono usare i doppi apici invece dei singoli apici.}

@cindex output, formato
@cindex formato, output

@item -f, --format=@var{formato}
Formati di output.  Come @code{formato} si può scegliere tra
@code{ps}, @code{pdf} e @code{png}.

Esempio: @code{lilypond -fpng @var{file}.ly}

@item -h, --help
Mostra una sintesi dell'utilizzo.

@item -H, --header=@var{CAMPO}
Estrae un campo dell'intestazione nel file @file{NOME.@var{CAMPO}}.

@item -i, --init=@var{file}
Imposta il file di inizializzazione su @var{file} (predefinito: @file{init.ly}).

@cindex ricerca dei file
@cindex percorso di ricerca

@item -I, --include=@var{directory}

È possibile assegnare più opzioni -I.  La ricerca inizierà nella prima
Aggiunge @var{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.

@cindex gabbia chroot, esecuzione all'interno di

@item -j, --jail=@var{utente},@var{gruppo},@var{gabbia},@var{directory}
Esegue @command{lilypond} in una gabbia chroot.

L'opzione @option{--jail} fornisce un'alternativa più flessibile a
@option{--safe} quando la formattazione di LilyPond è messa a disposizione attraverso
un server web o quando LilyPond esegue sorgenti provenienti dall'esterno
(si veda @ref{Advanced command line options for LilyPond}).

L'opzione @option{--jail} modifica la radice di @command{lilypond} in
@var{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 @var{directory}.  Questa configurazione
garantisce che non sia possibile (almeno in teoria) uscire dalla gabbia.  Si noti
che perché @option{--jail} funzioni @command{lilypond} deve essere eseguito come root;
di solito questo si fa in modo sicuro col comando @command{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 @emph{dentro la gabbia}.  Una configurazione tipica comprende i seguenti
elementi:

@table @asis

@item Impostare un filesystem distinto
Si dovrebbe creare un filesystem separato LilyPond, così che possa essere
montato con opzioni di sicurezza come @code{noexec}, @code{nodev}, e
@code{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.

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

@item 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, @file{/usr/share/lilypond}).

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

@item Eseguire LilyPond
In una gabbia montata con @code{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 @command{sudo}.  È una buona idea limitare il
numero di secondi di tempo della CPU che LilyPond può usare (ad esempio con
@command{ulimit -t}), e, se il sistema operativo lo permette, la quantità di
memoria che può essere allocata.  Si veda anche @ref{LilyPond in chroot jail}.
@end table

@cindex loglevel
@cindex output dettagliato

@item -l, --loglevel=@var{LIVELLO}
Imposta la verbosità dell'output della console su @var{LIVELLO}. I valori possibili sono:
@table @code

@item NONE
Nessun output, nemmeno i messaggi di errore.

@item ERROR
Solo i messaggi di errore, niente avvisi o messaggi di elaborazione.

@item WARN
Avvisi e messaggi di errore, nessun messaggio di elaborazione.

@item BASIC_PROGRESS
Messaggi di elaborazione di base (riuscita), avvisi e errori.

@item PROGRESS
Tutti i messaggi di elaborazione, avvisi e errori.

@item INFO (predefinito)
Messaggi di elaborazione, avvisi, errori e ulteriori informazioni di esecuzione.

@item DEBUG
Tutti i messaggi possibili, incluso l'output verboso di debug.

@end table

@cindex directory, dirigere l'output in
@cindex output, impostare il nome del file
@cindex output, directory

@item -o, --output=@var{FILE} o @var{CARTELLA}
Imposta il file di output predefinito @var{FILE} oppure, se una cartella con
quel nome esiste già, dirige l'output in @var{CARTELLA}, prendendo il nome
del file dal file di input.  In entrambi i casi verrà aggiunto il suffisso
appropriato (ad esempio @code{.pdf} per il pdf).

@cindex PS (Postscript), output
@cindex Postscript (PS), output
@cindex output, PS (Postscript)

@item --ps
Genera PostScript.

@cindex PNG (Portable Network Graphics), output
@cindex output, PNG (Portable Network Graphics)

@item --png
Genera immagini di ogni pagina in formato PNG.  Questo implica
@option{--ps}.  La risoluzione in DPI dell'immagine può essere impostata con
@example
-dresolution=110
@end example

@cindex PDF (Portable Document Format), output
@cindex output, PDF (Portable Document Format)

@item --pdf
Genera PDF.  Questo implica @option{--ps}.

@item -v, --version
Mostra informazioni sulla versione.

@item -V, --verbose
Aumenta la prolissità: mostra i percorsi completi di tutti i file letti e dà
informazioni sui tempi.

@item -w, --warranty
Mostra la garanzia con cui viene distribuito GNU LilyPond.  (Distribuito
con @strong{NESSUNA GARANZIA}!)

@end table


@node Opzioni avanzate della linea di comando per LilyPond
@unnumberedsubsec Opzioni avanzate della linea di comando per @command{lilypond}
@translationof Advanced command line options for LilyPond

@table @code

@item -d@var{[nome-opzione]}=@var{[valore]},--define-default=@var{[nome-opzione]}=@var{[valore]}
Imposta l'equivalente funzione interna di Scheme su @var{valore}.

@example
-dbackend=svg
@end example

Se non viene specificato un @var{valore}, viene usato il valore
predefinito.  Per disabilitare un'opzione, si può usare il
prefisso @code{no-} prima di @var{nome-opzione}, ad esempio

@cindex punta e clicca, linea di comando

@example
-dpoint-and-click=#f
@end example

@noindent
è equivalente a
@example
-dno-point-and-click
@end example
@end table

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

@multitable @columnfractions .33 .16 .51
@item @strong{Simbolo}
@tab @strong{Valore}
@tab @strong{Spiegazione/Opzioni}

@item @code{anti-alias-factor}
@tab @code{1}
@tab Elabora a una risoluzione più alta (usando un certo fattore) e ridimensiona
il risultato per evitare gli @q{artefatti} nelle immagini @code{PNG}.

@item @code{aux-files}
@tab @code{#t}
@tab Crea i file @code{.tex}, @code{.texi}, @code{.count} nel backend
@code{EPS}.

@item @code{backend}
@tab @code{ps}
@tab Seleziona il backend.  I file Postscript (predefinito) includono i tipi di
carattere @code{TTF}, @code{Type1} e @code{OTF}.  Non vengono inclusi i sottoinsiemi
di questi tipi.  Se si usa un set di caratteri @q{orientali}, si possono ottenere
file di grosse dimensioni.

@item
@tab @code{eps}
@tab Encapsulated PostScript.  Invia ogni pagina (sistema) in un file
@file{EPS} separato, senza font, e in un unico file @file{EPS} con
tutte le pagine (sistemi) inclusi i font.  Questa è la modalità
predefinita di @command{lilypond-book}.

@item
@tab @code{null}
@tab non produce la stampa della partitura; ha lo stesso
effetto di @code{-dno-print-pages}.

@item
@tab @code{scm}
@tab Estrae i comandi di disegno grezzi e interni, basati su Scheme.

@item
@tab @code{svg}
@tab Scalable Vector Graphics.
Crea un singolo file SVG per ogni pagina dell'output.
L'informazione relativa ai tipi di carattere non è incorporata, dunque
il lettore SVG dovrà avere accesso ai tipi di carattere per avere una
resa ottimale.
Si raccomanda di non usare gli @q{alias} o le @q{liste} dei tipi di carattere
se il proprio lettore SVG non è in grado di gestirli.  Consultare anche
l'opzione @code{svg-woff}.
@end multitable

@noindent
@strong{Nota per il backend svg:}
I tipi di carattere predefiniti di LilyPond (@code{LilyPond Serif},
@code{LilyPond Sans Serif} e @code{LilyPond Monospace}) sono solo alias
@emph{locali}; dunque quando si usa il backend @code{svg} è obbligatorio
impostare esplicitamente i tipi di carattere predefiniti;

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

Leggere anche @ruser{Entire document fonts}.

@multitable @columnfractions .33 .16 .51

@item @code{check-internal-types}
@tab @code{#f}
@tab Controlla l'assegnazione di ogni proprietà per i tipi.

@item @code{clip-systems}
@tab @code{#f}
@tab Estrae frammenti musicali da una partitura.  Per far ciò è necessario
che sia stata definita la funzione @code{clip-regions} all'interno del blocco
@code{\layout}.  Maggiori informazioni in @ruser{Extracting fragments of music}.
Nessun frammento verrà estratto se questa opzione è usata insieme
all'opzione @option{-dno-print-pages}.

@item @code{datadir}
@tab
@tab Prefisso per i file di dati (sola lettura).

@item @code{debug-gc}
@tab @code{#f}
@tab Scarica le statistiche sul debug della memoria.

@item @code{debug-gc-assert-parsed-dead}
@tab @code{#f}
@tab Per il debug della memoria: Assicura che tutti i riferimenti agli oggetti
analizzati siano eliminati. Questa è un'opzione interna e viene abilitata
automaticamente da @code{`-ddebug-gc'}.

@item @code{debug-lexer}
@tab @code{#f}
@tab Debug dell'analizzatore lessicale flex.

@item @code{debug-page-breaking-scoring}
@tab @code{#f}
@tab Crea le partiture per diverse configurazioni di interruzione di pagina.

@item @code{debug-parser}
@tab @code{#f}
@tab Debug dell'analizzatore bison.

@item @code{debug-property-callbacks}
@tab @code{#f}
@tab Debug delle catene cicliche di callback.

@item @code{debug-skylines}
@tab @code{#f}
@tab Debug skylines.

@item @code{delete-intermediate-files}
@tab @code{#t}
@tab Cancella i file @code{.ps} intermedi e inutilizzabili creati durante
la compilazione.

@item @code{dump-cpu-profile}
@tab @code{#f}
@tab Scarica l'informazione sui tempi (dipendente dal sistema).

@item @code{dump-profile}
@tab @code{#f}
@tab Scarica l'informazione sulla memoria e il tempo per ogni file.

@item @code{dump-signatures}
@tab @code{#f}
@tab Scarica le firme dell'output di ogni sistema. Usato per testare le regressioni.

@item @code{eps-box-padding}
@tab @code{#f}
@tab Sposta il margine sinistro della cornice EPS dell'output della quantità
specificata (in mm).

@item @code{gs-load-fonts}
@tab @code{#f}
@tab Carica i font attraverso Ghostscript.

@item @code{gs-load-lily-fonts}
@tab @code{#f}
@tab Carica solo i font LilyPond attraverso Ghostscript.

@item @code{gui}
@tab @code{#f}
@tab Esegue il programma senza stampare messaggi e redirige tutto l'output in un file di log.
@end multitable

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

@multitable @columnfractions .33 .16 .51
@item @code{help}
@tab @code{#f}
@tab Mostra questo aiuto.

@item @code{include-book-title-preview}
@tab @code{#t}
@tab Include i titoli dei libri nelle immagini di anteprima.

@item @code{include-eps-fonts}
@tab @code{#t}
@tab Include i font in file EPS con sistemi separati.

@item @code{include-settings}
@tab @code{#f}
@tab Include il file per le impostazioni globali, questo viene incluso prima
che la partitura sia elaborata.

@item @code{job-count}
@tab @code{#f}
@tab Elabora in parallelo, usando il dato numero di lavori.

@item @code{log-file}
@tab @code{#f [file]}
@tab Se la stringa @code{FOO} viene assegnata come secondo argomento,
redirige l'output nel file @code{FOO.log}.

@item @code{max-markup-depth}
@tab @code{1024}
@tab 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.

@item @code{midi-extension}
@tab @code{"midi"}
@tab Imposta l'estensione predefinita per il file MIDI sulla stringa specificata.

@item @code{music-strings-to-paths}
@tab @code{#f}
@tab Converte le stringhe di testo in percorsi quando i glifi appartengono a
un font musicale.

@item @code{paper-size}
@tab @code{\"a4\"}
@tab Imposta la dimensione predefinita del foglio.  Nota che la stringa deve
essere compresa tra virgolette precedute dal segno di escape.

@item @code{pixmap-format}
@tab @code{png16m}
@tab Imposta il formato di output di GhostScript per le immagini raster.

@item @code{point-and-click}
@tab @code{#t}
@tab Aggiunge i collegamenti @q{punta e clicca} all'output PDF e SVG. Si veda
@ref{Point and click}.

@item @code{preview}
@tab @code{#f}
@tab Crea immagini di anteprima oltre al normale output.
@end multitable

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

Per impedire il normale output, si usano le opzioni @option{-dprint-pages} o
@option{-dno-print-pages} in base alle proprie esigenze.

@multitable @columnfractions .33 .16 .51
@item @code{print-pages}
@tab @code{#t}
@tab Genera le pagine complete (predefinito).  @option{-dno-print-pages} è
utile in combinazione con @option{-dpreview}.

@item @code{profile-property-accesses}
@tab @code{#f}
@tab Mantiene una statistica delle chiamate di funzione @code{get_property()}.

@item @code{protected-scheme-parsing}
@tab @code{#t}
@tab Continua se l'analizzatore coglie degli errori nel codice scheme interno
al file di input. Se impostato su @code{#f}, in caso di errore si ferma e
mostra la traccia di stack.

@item @code{read-file-list}
@tab @code{#f [file]}
@tab Specifica il nome di un file che contiene una lista di file di input da
elaborare.

@item @code{relative-includes}
@tab @code{#f}
@tab Quando elabora un comando @code{\include}, cerca il file incluso
in posizione relativa al file corrente (invece che in posizione assoluta).

@item @code{resolution}
@tab @code{101}
@tab Imposta la risoluzione per generare immagini @code{PNG} su un certo
valore (in dpi).

@item @code{safe}
@tab @code{#f}
@tab Non si fida dell'input nel file @code{.ly}.
@end multitable

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

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

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

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

@option{-dsafe} @emph{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 @option{--jail} è un'alternativa più sicura, ma richiede più lavoro
per configurarla.  Si veda @ref{Basic command line options for LilyPond}.

@multitable @columnfractions .33 .16 .51
@item @code{separate-log-files}
@tab @code{#f}
@tab Per i file di input @code{FILE1.ly}, @code{FILE2.ly}, etc. salva i dati di
log nei file @code{FILE1.log}, @code{FILE2.log}, @dots{}

@item @code{show-available-fonts}
@tab @code{#f}
@tab Elenca i nomi di font disponibili.

@item @code{strict-infinity-checking}
@tab @code{#f}
@tab Forza il blocco del programma quando si incontrano eccezioni @code{Inf} e
@code{NaN} sui numeri in virgola mobile.

@item @code{strip-output-dir}
@tab @code{#t}
@tab Non usa le directory dei file di input per costruire i nomi dei file
di output.

@item @code{strokeadjust}
@tab @code{#f}
@tab 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.


@item @code{svg-woff}
@tab @code{#f}
@tab Usa i file woff dei tipi di carattere nel backend SVG.
@c TODO: Paragrafo da chiarire, vedi issue 4650
Se si usa il file woff nel modo corretto, non è necessario installare
nell'ambiente del lettore SVG i tipi di carattere usati dai file SVG.
Tuttavia LilyPond non contiene un file woff per il testo, che è richiesto.

@item @code{trace-memory-frequency}
@tab @code{#f}
@tab Registra molte volte al secondo l'uso delle celle da parte di Scheme.  Salva i
risultati in @code{FILE.stacks} e @code{FILE.graph}.

@item @code{trace-scheme-coverage}
@tab @code{#f}
@tab Registra la copertura dei file Scheme in @code{FILE.cov}.

@item @code{verbose}
@tab @code{#f}
@tab Output dettagliato, ovvero livello di log DEBUG (sola lettura).

@item @code{warning-as-error}
@tab @code{#f}
@tab Trasforma tutti i messaggi di avviso e di @q{errore di programmazione} in errori.
@end multitable


@node Variabili d'ambiente
@unnumberedsubsec Variabili d'ambiente
@translationof Environment variables

@cindex LANG
@cindex LILYPOND_DATADIR

@command{lilypond} riconosce le seguenti variabili d'ambiente:
@table @code
@item 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 @file{ly/}, @file{ps/}, @file{tex/}, etc.

@item LANG
Determina la lingua per i messaggi di avviso.

@item LILYPOND_LOGLEVEL
Il livello di log (loglevel) predefinito. Se LilyPond viene chiamato senza un
livello di log esplicito (ovvero senza l'opzione @option{--loglevel} della
linea di comando), viene usato questo valore.

@item 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 è @code{70}.

@end table


@node LilyPond in una gabbia chroot
@unnumberedsubsec LilyPond in una gabbia chroot
@translationof LilyPond in chroot jail

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 @code{sudo} in alcune situazioni.

@itemize

@item Installa i pacchetti necessari: LilyPond, GhostScript e ImageMagick.

@item Crea un nuovo utente dal nome @code{lily}:

@example
adduser lily
@end example

@noindent
Questo comando creerà anche un nuovo gruppo per l'utente @code{lily}, e una
cartella home,
@code{/home/lily}

@item Nella cartella home dell'utente @code{lily} crea un file da usare come
filesystem separato:

@example
dd if=/dev/zero of=/home/lily/loopfile bs=1k count= 200000
@end example

@noindent
In questo esempio è stato creato un file di 200MB da usare come filesystem della
gabbia.

@item Crea un dispositivo di loop, crea e monta un filesystem, quindi crea
una cartella scrivibile dall'utente @code{lily}:

@example
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
@end example

@item Nella configurazione dei server, JAIL sarà @code{/mnt/lilyloop}
e DIR sarà @code{/lilyhome}.

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

Puoi usare @code{sed} per creare i comandi di copia necessari per un certo
eseguibile:

@example
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
@end example

@end itemize

@subheading Script di esempio per Ubuntu 8.04 a 32-bit

@example
#!/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
@end example

@c " keep quote signs balanced for context-sensitive editors

@node Messaggi di errore
@section Messaggi di errore
@translationof Error messages

@cindex messaggi di errore
Quando si compila un file possono apparire vari messaggi di errore:

@table @emph

@item Avvertimento
@cindex avvertimento
Qualcosa appare sospetto.  Se stai cercando di fare qualcosa di insolito
allora comprenderai il messaggio e potrai ignorarlo.
Tuttavia di solito i messaggi di avvertimento indicano che il file di input ha
qualcosa che non va.

@item Errore
@cindex errore
C'è qualcosa di assolutamente sbagliato.  Il passo attualmente in elaborazione
(analisi, interpretazione o formattazione) verrà completato, ma il passo
successivo verrà saltato.

@item Errore fatale
@cindex errore fatale
C'è qualcosa di assolutamente sbagliato e LilyPond non può continuare.  Questo
accade raramente.  La causa più comune è un'errata installazione dei tipi di
carattere.

@item Errore Scheme
@cindex traccia, Scheme
@cindex traccia di chiamata
@cindex errore Scheme
Gli errori che capitano mentre si esegue del codice Scheme sono individuati
dall'interprete Scheme.  Se si esegue con l'opzione di prolissità (@code{-V} o
@option{--verbose}), viene stampata una traccia della chiamata di funzione
responsabile dell'errore.

@item Errore di programmazione
@cindex Errore di programmazione
Si è verificata una qualche incongruenza interna.  Questi messaggi di errore
servono ad aiutare programmatori e debugger.  Di solito si possono
ignorare.  Talvolta sono talmente numerosi da nascondere il resto
dell'output.

@item Sospeso (core dumped)
@cindex Sospeso (core dumped)
Segnala un serio errore di programmazione che ha mandato in crash il
programma.  Questi errori sono considerati critici.  Se ti imbatti in un
errore simile, invia una segnalazione di errore.
@end table

@cindex errori, formato del messaggio
Se gli avvertimenti e gli errori possono essere collegati
a una parte specifica del file di input, i messaggi di errore
hanno la seguente forma

@example
@var{file}:@var{riga}:@var{colonna}: @var{messaggio}
@var{riga di input responsabile dell'errore}
@end example

Nella riga responsabile si inserisce un a capo per indicare la colonna
in cui è stato trovato l'errore.  Ad esempio,

@example
test.ly:2:19: error: not a duration: 5
  @{ c'4 e'
           5 g' @}
@end example

Queste posizioni indicano il punto in cui LilyPond ritiene più probabile
che siano apparsi l'avvertimento o l'errore, ma (per loro
stessa natura) avvertimenti ed errori capitano quando succede qualcosa
di imprevisto.  Se non riesci a vedere un errore nella riga suggerita,
prova a controllare una o due righe sopra la posizione indicata.

Attenzione: l'analisi degli errori è sempre attivata nel corso dei vari
passaggi di elaborazione.  Per esempio, se ci sono parti di input che
sono elaborati varie volte (es: per produrre l'output midi e quello
grafico) oppure se viene usata la stessa variabile musicale in vari
contesti, potrebbe apparire lo stesso messaggio molteplici volte.  Anche
la diagnosi eseguita in uno degli @q{ultimi} passaggi (es: controlli di
battuta) può apparire varie volte.

Maggiori informazioni sugli errori si trovano in @ref{Common errors}.


@node Errori comuni
@section Errori comuni
@translationof Common errors

Le condizioni di errore descritte di seguito capitano spesso, ma la causa
non è ovvia né facile da trovare.  Una volta che sono state individuate e
comprese, è facile gestirle.


@menu
* La musica esce dalla pagina::
* Appare un rigo in più::
* Messaggio di errore Unbound variable %::
* Messaggio di errore FT_Get_Glyph_Name::
* Avvertimento sul fatto che le affinità del rigo devono solo diminuire::
* Messaggio di errore new inaspettato::
* Avviso questa voce ha bisogno di un'impostazione voiceXx o shiftXx::
@end menu

@node La musica esce dalla pagina
@unnumberedsubsec La musica esce dalla pagina
@translationof Music runs off the page

Se la musica esce dalla pagina al di là del margine destro o appare
eccessivamente compressa, quasi sempre è dovuto all'inserimento di
una durata errata di una nota, che fa sì che l'ultima nota di una misura si
estenda oltre la barra di divisione.  Non è sbagliato se la nota finale di
una misura non termina entro la barra di divisione inserita automaticamente, perché
semplicemente si assume che la nota continui nella misura successiva.  Ma se
si presenta una lunga sequenza di misure simili, la musica può
apparire compressa o può uscire dalla pagina perché gli a capo
automatici possono essere inseriti soltanto alla fine di misure complete,
ovvero quando tutte le note finiscono prima o alla fine della misura.

@warning{Una durata sbagliata può inibire l'interruzione di
linea, portando a una linea di musica estremamente compressa o
a musica che esce dalla pagina.}

La durata errata può essere trovata facilmente se si usano i controlli di
battuta, si veda @ruser{Controlli di battuta e del numero di battuta}.

Se si vuole davvero ottenere una serie di tali misure sovrapposte
bisogna inserire una barra di divisione invisibile nel punto in cui
si desidera l'interruzione di linea.  Per i dettagli si veda
@ruser{Stanghette}.


@node Appare un rigo in più
@unnumberedsubsec Appare un rigo in più
@translationof An extra staff appears

Se i contesti non sono creati esplicitamente con @code{\new} o
@code{\context}, saranno creati senza avviso appena si incontra
un comando che non può essere applicato a un contesto
esistente.  Nelle partiture semplici la creazione automatica dei contesti
è utile: infatti la maggior parte degli esempi nei manuali LilyPond sfrutta
questa semplificazione.  Talvolta, però, la creazione silenziosa di contesti
può causare la comparsa di nuovi righi o partiture non desiderate.  Ad esempio,
si potrebbe pensare che il seguente codice colori di rosso tutte le teste
delle note nel rigo, ma in realtà produce due righi, di cui il più basso
conserva il colore nero predefinito per le teste delle note.

@lilypond[quote,verbatim,fragment]
\override Staff.NoteHead.color = #red
\new Staff { a' }
@end lilypond

Questo accade perché non esiste un contesto @code{Staff} quando viene
elaborata l'istruzione di override, quindi ne viene implicitamente creato uno e
l'override viene applicato ad esso.  Ma poi il comando @code{\new Staff} crea
un altro rigo separato nel quale vengono inserite le note.  Il codice
corretto per colorare le teste di tutte le note è

@lilypond[quote,verbatim]
\new Staff {
  \override Staff.NoteHead.color = #red
  a'
}
@end lilypond


@node Messaggio di errore Unbound variable %
@unnumberedsubsec Messaggio di errore Unbound variable %
@translationof Error message Unbound variable %

Questo messaggio di errore comparirà in fondo alla console di
output o nel file di log insieme al messaggio @qq{GUILE signalled an error @dots{}}
ogni volta che viene chiamata una routine di Scheme che contenga (erroneamente)
un commento @emph{LilyPond} invece di un commento @emph{Scheme}.

I commenti LilyPond iniziano con un segno di percentuale, (@code{%}), e non
devono essere usati all'interno delle routine di Scheme.  I commenti Scheme
iniziano con un punto e virgola, (@code{;}).

@node Messaggio di errore FT_Get_Glyph_Name
@unnumberedsubsec Messaggio di errore FT_Get_Glyph_Name
@translationof Error message FT_Get_Glyph_Name

Questo messaggio di errore compare nella console di output o nel file di log file
se un file di input contiene un carattere non-ASCII e non è stato salvato nella
codifica UTF-8.  Per dettagli si veda @ruser{Text encoding}.


@node Avvertimento sul fatto che le affinità del rigo devono solo diminuire
@unnumberedsubsec Avvertimento sul fatto che le affinità del rigo devono solo diminuire
@translationof Warning staff affinities should only decrease

Questo avvertimento può apparire se non ci sono dei righi nell'output,
ad esempio se ci sono solo un contesto @code{ChordName} e un
contesto @code{Lyrics}, come in un lead sheet.  Si possono evitare questi
messaggi di avvertimento facendo in modo che uno dei contesti si comporti
come un rigo inserendo

@example
\override VerticalAxisGroup.staff-affinity = ##f
@end example

@noindent
all'inizio del contesto.  Per dettagli si veda @qq{Spacing of non-staff lines} in
@ruser{Flexible vertical spacing within systems}.

@node Messaggio di errore new inaspettato
@unnumberedsubsec Messaggio di errore @code{@bs{}new} inaspettato
@translationof Error message unexpected new

Un blocco @code{\score} deve contenere una @emph{singola} espressione musicale.
Se invece contiene vari @code{\new Staff}, @code{\new StaffGroup} o simili
contesti introdotti con @code{\new} senza che questi siano racchiusi tra
parentesi graffe, @code{@{ @dots{} @}}, o doppie parentesi uncinate, @code{<< @dots{} >>},
ovvero così:

@example
\score @{
  % Invalido! Genera l'errore: errore di sintassi, \new inaspettato
  \new Staff @{ @dots{} @}
  \new Staff @{ @dots{} @}
@}
@end example

@noindent
verrà generato questo messaggio di errore.

Per evitare l'errore, è sufficiente racchiudere tutti i blocchi @code{\new} tra
parentesi graffe o doppie parentesi uncinate.

Se si usano le parentesi graffe, i blocchi @code{\new} appariranno in
modo sequenziale:

@lilypond[quote,verbatim]
\score {
  {
    \new Staff { a' a' a' a' }
    \new Staff { g' g' g' g' }
  }
}
@end lilypond

@noindent
ma è più probabile che si debbano usare le doppie parentesi uncinate in modo
che i nuovi righi siano avviati in parallelo, ovvero contemporaneamente:

@lilypond[quote,verbatim]
\score {
  <<
    \new Staff { a' a' a' a' }
    \new Staff { g' g' g' g' }
  >>
}
@end lilypond

@node Avviso questa voce ha bisogno di un'impostazione voiceXx o shiftXx
@unnumberedsubsec Avviso questa voce ha bisogno di un'impostazione @bs{}voiceXx o @bs{}shiftXx
@translationof Warning this voice needs a voiceXx or shiftXx setting

Se note appartenenti a due voci diverse con gambi nella stessa
direzione si trovano nello stesso momento musicale, e per le voci
non è stato specificato alcun spostamento, quando si compila il
file apparirà il messaggio di avviso
@samp{avviso: questa voce ha bisogno di un'impostazione \voiceXx o \shiftXx}.
Tale avviso apparirà anche quando le note non hanno gambi visibili,
come nel caso delle semibrevi, se i gambi di note più brevi della
stessa altezza sono nella stessa direzione.

Ricorda che la direzione del gambo, a meno che non sia specificata, per
esempio tramite @code{\voiceOne}, etc., dipende dalla posizione della
nota sul rigo.  Dunque se la direzione del gambo non è specificata, l'avviso
apparirà solo quando i gambi si trovano nella stessa direzione, ovvero
quando le note si trovano nella stessa metà del rigo.

Si possono evitare questi avvisi mettendo le note in voci in cui siano
indicate le direzioni dei gambi e gli spostamenti, per esempio usando
@code{\voiceOne}, etc.

Le note delle voci con un numero maggiore di due, @code{\voiceThree} etc., sono
spostate automaticamente per avitare la collisione tra colonne di note.  Ciò
causa uno spostamento visibile delle note con gambo, mentre le semibrevi
non sono spostate visibilmente, a meno che non si verifichi una reale collisione
tra teste di nota oppure quando le voci si incrociano rispetto al loro ordine
naturale (quando le note di @code{\voiceThree} sono più alte di quelle di
@code{\voiceOne}, etc.)

@seealso
@rlearning{Definire esplicitamente le voci},
@rlearning{Esempio musicale},
@ruser{Polifonia su un solo rigo},
@ruser{Risoluzione delle collisioni}.