GNU LilyPond – Utilisation des programmes: 1.2 Utilisation en ligne de commande

[ << Exécution de lilypond ]	[Racine][Table des matières][Index][ ? ]			[ Mise à jour avec convert-ly >> ]
[ < Utilisation habituelle ]		[ Plus haut: Exécution de lilypond ]	[ Lancement de LilyPond > ]

1.2 Utilisation en ligne de commande

Nous nous intéresserons ici aux spécificités de LilyPond employé en ligne de commande. La ligne de commande permet de faire appel à certaines options particulières. D’autre part, certains utilitaires associés, tel que midi2ly, ne sont disponibles qu’en ligne de commande.

Par « ligne de commande », nous entendons l’interface de commande du système. Les utilisateurs de Windows seront certainement plus familiers des termes « fenêtre DOS » ou « invite de commande ». Quant aux utilisateurs de MacOS X, ils connaissent assurément les termes « console » et « terminal ». Les paramétrages spécifiques au système MacOS font l’objet d’un chapitre particulier.

Notre propos n’est pas ici d’expliquer ce qu’est l’interface de commande pour un système informatique ni comment elle fonctionne. Aussi, si vous ne savez de quoi il retourne, nous vous renvoyons aux nombreuses documentations que vous pourrez trouver sur ce sujet.

[ << Exécution de lilypond ]	[Racine][Table des matières][Index][ ? ]			[ Mise à jour avec convert-ly >> ]
[ < Utilisation en ligne de commande ]		[ Plus haut: Utilisation en ligne de commande ]	[ > ]

Lancement de LilyPond

L’exécutable lilypond en ligne de commande se lance ainsi :

lilypond [option]… fichier…

Lorsque le fichier est fourni sans extension, LilyPond présume qu’il s’agit de ‘.ly’. Pour interpréter directement l’entrée standard (stdin), fournissez un tiret (-) en lieu et place de fichier.

Le traitement de ‘monfichier.ly’ produira ‘monfichier.ps’ et ‘monfichier.pdf’. Vous pouvez spécifier plusieurs fichiers à la fois ; ils seront traités indépendamment les uns des autres.¹

Lorsque ‘monfichier.ly’ contient plus d’une section \book, les fichiers produits – à partir du deuxième – seront numérotés. Par ailleurs, la valeur affectée à output-suffix sera insérée entre la racine et le numéro. Par exemple, un fichier racine qui contiendrait

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

fournira grâce à LilyPond ‘racine-violon.pdf’ et ‘racine-cello-1.pdf’.

[ << Exécution de lilypond ]	[Racine][Table des matières][Index][ ? ]			[ Mise à jour avec convert-ly >> ]
[ < Lancement de LilyPond ]		[ Plus haut: Lancement de LilyPond ]	[ Options basiques de lilypond > ]

Utilisation de LilyPond avec les fonctionnalités standard de l’interpréteur

Dans la mesure où LilyPond est une application qui fonctionne en ligne de commande, les fonctionnalités de l’interpréteur utilisé pour lancer LilyPond peuvent se révéler utiles.

Par exemple,

lilypond *.ly

traitera tous les fichiers LilyPond présents dans le répertoire en cours.

Rediriger, par exemple dans un fichier, ce qui est émis à l’écran peut s’avérer utile.

lilypond fichier.ly 1> stdout.log

lilypond fichier.ly 2> stderr.log

lilypond fichier.ly &> tous.log

redirigeront respectivement le « verbiage normal », les erreurs ou tout, dans un fichier texte.

Consultez avant tout la documentation de votre interpréteur habituel – terminal, console, etc. – pour vérifier qu’il prend en charge les options dans cette syntaxe.

Voici comment traiter un jeu de fichiers répartis dans un répertoire donné ainsi que tous ses différents sous-répertoires. Les fichiers résultants seront regroupés dans le répertoire à partir duquel la commande a été exécutée, non selon l’emplacement des fichiers sources.

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

Cette commande, bien qu’effective uniquement dans un terminal, devrait être fonctionnelle aussi pour les utilisateurs de MacOS X.

Les utilisateurs de windows utiliseront l’instruction

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

dans l’interpréteur de commandes, qui se trouve normalement sous Démarrer > Accessoires > Interpréteur de commandes ou, pour la version 8, en faisant une recherche sur « interpréteur de commande ».

Par ailleurs, il est possible de spécifier de manière explicite le chemin d’accès au dossier comportant des sous-répertoires où se trouvent les fichiers sources, à l’aide de l’option /p :

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

Dans le cas où ce chemin d’accès comporte des espaces, l’intégralité de ce chemin devra être borné par des guillemets informatiques :

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

[ << Exécution de lilypond ]	[Racine][Table des matières][Index][ ? ]			[ Mise à jour avec convert-ly >> ]
[ < ]		[ Plus haut: Utilisation en ligne de commande ]	[ Options avancées de lilypond > ]

Options basiques de `lilypond`

Différentes options sont disponibles en ligne de commande :

-b, --bigpdfs

Les fichiers PDF générés peuvent être beaucoup plus lourd que la normale selon le degré d’optimisation des fontes. Néanmoins, lorsque plusieurs fichiers PDF sont inclus dans un document pdftex, xetex ou luatex, ils peuvent faire l’objet d’un traitement supplémentaire par ghostscript afin de fusionner les données de fontes redondantes et ainsi obtenir un fichier PDF significativement plus léger.

lilypond -b monfichier

Puis lancer ghostscript :

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

pdfsizeopt.py vient alors en complément pour optimiser encore la taille du fichier :

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

-d, --define-default=variable=valeur

Voir Options avancées de lilypond.

-e, --evaluate=expr

Évalue l’expression Scheme expr avant d’analyser tout fichier ‘.ly’. Lorsque vous spécifiez l’option ‘-e’ à plusieurs reprises, l’évaluation sera faite en séquence.

Dans la mesure où l’expression est évaluée par le module guile-user, vous devrez, dès lors que expr utilise des définitions, spécifier

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

en ligne de commande, et ajouter la ligne

#(use-modules (guile-user))

en tête de votre fichier ‘.ly’.

Note : Les utilisateurs de Windows doivent utiliser des guillemets doubles " en lieu et place des guillemets simples '.

-f, --format=format

Détermine le format à produire. Il peut s’agir de ps, pdf ou png.

Exemple : lilypond -fpng monfichier.ly

Les formats svg et eps s’obtiennent à l’aide de l’option -dbackend – voir Options avancées de lilypond.

-h, --help

Affiche un résumé des commandes.

-H, --header=CHAMP

Recopie le champ d’entête dans le fichier ‘RACINE.CHAMP’.

-i, --init=fichier

Définit fichier (par défaut ‘init.ly’) en tant que fichier d’initialisation.

-I, --include=répertoire

Ajoute répertoire au chemin de recherche pour les inclusions.

Vous pouvez mentionner plusieurs fois l’option ‘-I’, auquel cas la recherche commencera dans le premier répertoire inclus et, si le fichier en question ne s’y trouve pas, les répertoires suivants seront examinés l’un après l’autre.

-j, --jail=user,group,jail,dir

Lance lilypond dans un environnement protégé.

L’option ‘--jail’ est une alternative qui offre plus de flexibilité que l’option ‘--safe’ lorsque LilyPond est installé sur un serveur web ou traite des fichiers externes – voir Options avancées de lilypond.

L’option ‘--jail’ va détourner la racine de lilypond sur jail juste avant d’effectuer la compilation à proprement parler. L’utilisateur et le groupe sont modifiés en conséquence, et le répertoire en cours devient dir. Ces réglages assurent – du moins en théorie – l’impossibilité de s’échapper de la cellule. Notez cependant que, pour que l’option ‘--jail’ soit fonctionnelle, lilypond doit être lancé en tant qu’administrateur – ce qui se réalise aisément à l’aide de la commande sudo.

La création d’un environnement sécurisé requiert quelques précautions dans la mesure où LilyPond doit disposer de tout ce dont il a besoin pour compiler le fichier source à l’intérieur de la cellule. L’ermitage, avant d’être viable, requiert donc les étapes suivantes :

Création d’un système de fichiers indépendant

L’intérêt d’un système de fichiers dédié à LilyPond réside dans le fait qu’on peut le brider à l’aide des options noexec, nodev et nosuid. Il sera de fait impossible de lancer des exécutables ou d’écrire sur un périphérique à partir de LilyPond. Si vous n’avez pas l’intention de créer un tel système sur une partition séparée, vous pouvez avoir recours à un pseudo-périphérique (loop device) monté à partir d’un simple fichier de taille raisonnable. D’autre part, le recours à un système de fichiers indépendant permet de limiter l’espace dévolu à LilyPond.

Création d’un utilisateur spécifique

L’utilisation de LilyPond au sein de la cellule devrait être réservé à un utilisateur aux droits restreints. Il faudra donc créer un utilisateur et un groupe spécifiques – disons lily/lily – qui n’aura accès en écriture qu’à un unique répertoire déterminé par la valeur de dir.

Agencement des lieux

LilyPond a besoin d’un certain nombre de fichiers pour pouvoir tourner correctement. Ces fichiers devront donc tous se retrouver dans l’environnement protégé, distribués selon la même arborescence que dans le système d’origine. Ainsi l’intégralité de l’installation de LilyPond (en principe ‘/usr/share/lilypond’) doit y être dupliquée.

En cas de problème, lancer LilyPond en utilisant strace devrait vous permettre de déterminer quels fichiers manquent à l’appel.

Lancement de LilyPond

Dans un environnement protégé monté avec l’option noexec, il est impossible de lancer un quelconque programme extérieur. LilyPond ne saurait donc avoir recours à un moteur de traitement qui le mettrait dans cette situation. Comme nous l’avons vu plus haut, LilyPond sera lancé avec les privilèges de l’administrateur – privilèges qu’il perdra aussitôt –, ce qui peut nécessiter le recours à la commande sudo. Il est par ailleurs judicieux de limiter le temps processeur alloué à LilyPond – grâce à ulimit -t par exemple – ainsi que, si votre système le permet, la taille de la mémoire. Voir aussi Exécution de LilyPond en mode protégé.

-l, --loglevel=DEGRÉ

Règle le niveau de verbosité des messages console à DEGRÉ. Les différentes valeurs sont :

NONE: Aucun verbiage, même pas les messages d’erreur.
ERROR: Uniquement les messages d’erreur ; pas de message d’avertissement ni de progression.
WARN: Messages d’avertissement ou d’erreur ; pas d’information de progression.
BASIC_PROGRESS: Information de progression basique (réussite) et avertissements ou erreurs.
PROGRESS: Toutes les informations de progression, avertissements et erreurs.
INFO (par défaut): Informations de progression, avertissements et erreurs, ainsi que d’autres informations relatives à l’exécution.
DEBUG: Tout ce qui peut être affiché, y compris le verbiage utile au débogage.

-o, --output=FICHIER ou RÉPERTOIRE

Détermine le nom par défaut du fichier résultant à FICHIER ; lorsque l’argument RÉPERTOIRE correspond à un répertoire déjà existant, c’est là que les fichiers résultants seront déposés. Le suffixe adéquat sera ajouté (par ex. .pdf pour du pdf) dans tous les cas.

--ps

Génère du PostScript.

--png

Génère une image par page, au format PNG ; ceci sous-entend l’utilisation de ‘--ps’. La résolution de l’image, en DPI, peut se régler en ajoutant par exemple

-dresolution=110

--pdf

Génère du PDF. Ceci sous-entend l’utilisation de ‘--ps’.

-v, --version

Affiche le numéro de version.

-V, --verbose

Active le mode verbeux : affichage de l’intégralité du chemin d’accès de chaque fichier, et information des temps de traitement.

-w, --warranty

Affiche les informations de garantie applicables à GNU LilyPond – il est livré SANS GARANTIE !

[ << Exécution de lilypond ]	[Racine][Table des matières][Index][ ? ]			[ Mise à jour avec convert-ly >> ]
[ < Options basiques de lilypond ]		[ Plus haut: Utilisation en ligne de commande ]	[ Variables d'environnement > ]

Options avancées de `lilypond`

-d[nom-option]=[valeur],

–define-default=[nom-option]=[valeur] Affecte la valeur Scheme valeur à l’option interne nom-option du programme, comme par exemple

-dbackend=svg

En l’absence de valeur, le programme utilisera #t. Préfixer nom-option d’un no- vous permet de désactiver une option. Ainsi,

-dno-point-and-click

revient au même que

-dpoint-and-click=#f

Voici les différentes options disponibles, ainsi que leur valeur par défaut.

Symbole	Valeur	Observations
`anti-alias-factor`	`1`	Adopte une résolution supérieure (selon le facteur donné),puis réduit au niveau du résultat afin d’éviter les « distorsions » des images `PNG`.
`aux-files`	`#t`	Génère les fichiers `.tex`, `.texi` et `.count` pour le moteur de rendu `EPS`.
`backend`	`ps`	Détermine le format de sortie à utiliser par le moteur de traitement. Les fichiers PostScript (format par défaut) incluent les fontes `TTF`, `Type1` et `OTF`, et aucune substitution ne sera opérée pour ces fontes. Si vous utilisez des jeux de caractères orientaux, le fichier aura vite fait d’atteindre une taille conséquente.
	`eps`	Génère du PostScript encapsulé. Chaque page (système) fera l’objet d’un fichier ‘`EPS`’ particulier, sans fontes, auquel sera associé un fichier ‘`EPS`’ qui, lui, contiendra toutes les pages (systèmes) et les fontes. Notez qu’il s’agit du mode que `lilypond-book` utilise par défaut.
	`null`	Ne génère aucun fichier imprimable. Cette option est équivalente à `-dno-print-pages`.
	`scm`	Recopie littéralement les commandes Scheme internes de formatage.
	`svg`	Génère du Scalable Vector Graphics. Cette option permet de créer un fichier SVG par page. Les glyphes musicaux sont codés en tant que graphiques vectoriels mais les fontes textuelles ne sont pas incorporées aux fichiers ‘`SVG`’ résultants. Quel que soit le programme utilisé pour visionner ces fichiers, il devra avoir accès aux fontes en question pour pouvoir afficher correctement les textes et paroles. Il est préférable de ne pas recourir aux « alias de police » ni aux listes de fontes si la visionneuse de fichier SVG ne peut le traîter correctement. L’option supplémentaire `--svg-woff` – voir ci-après – permet d’utiliser les fontes WOFF (Web Open Font Format) avec le moteur SVG.

Note à propos des sorties SVG : Par défaut, LilyPond utilise des valeurs de font-family génériques – Serif, Sans Serif et Monospace. Le recours au moteur svg requiert donc que ces polices par défaut soient explicitement définies dans le fichier source :

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

Voir aussi Choix des fontes par défaut.

`check-internal-types`	`#f`	Vérifie qu’à chaque propriété est bien affecté un type.
`clip-systems`	`#f`	Extrait des fragments musicaux d’une partition. Ceci requiert que la fonction `clip-regions` a été définie au sein du bloc `\layout` – voir Extraction de fragments musicaux. Bien entendu, aucun fragment ne sera extrait si l’on utilise l’option ‘`-dno-print-pages`’
`datadir`		Détermine le préfixe des fichiers de données (lecture seule).
`debug-gc`	`#f`	Génère une copie brute de la mémoire, aux fins de débogage.
`debug-gc-assert-parsed-dead`	`#f`	Pour débogage de la mémoire : s’assure que toute référence à des objets analysés est effacée. Il s’agit d’une option interne qui est automatiquement activée par l’option `-ddebug-gc'.
`debug-lexer`	`#f`	Débogage de l’analyseur lexical flex.
`debug-page-breaking-scoring`	`#f`	Purge les calculs des configurations de saut de page.
`debug-parser`	`#f`	Débogage de l’analyseur bison.
`debug-property-callbacks`	`#f`	Débogage des chaînes de callback cycliques.
`debug-skylines`	`#f`	Débogage des lignes d’horizon.
`delete-intermediate-files`	`#t`	Supprime les fichiers `.ps` inutiles crées lors de la compilation.
`dump-cpu-profile`	`#f`	Génère une copie brute des informations de timing (dépend du système).
`dump-profile`	`#f`	Génère une copie brute de la mémoire et des temps de traitement pour chaque fichier.
`dump-signatures`	`#f`	Génère une copie des signatures de chaque système. Cette option est utilisée pour les tests de régression.
`embed-source-code`	`#f`	Intègre les fichiers source LilyPond au document PDF généré.
`eps-box-padding`	`#f`	Décale le bord gauche du typon EPS d’une valeur donnée en millimètres.
`font-export-dir`	`#f [répertoire]`	Répertoire dans lequel exporter les fontes en tant que fichiers PostScript.
`gs-load-fonts`	`#f`	Charge les fontes grâce à Ghostscript.
`gs-load-lily-fonts`	`#f`	Limite les fontes chargées par Ghostscript aux seules fontes LilyPond.
`gs-never-embed-fonts`	`#f`	Intime à Ghostscript d’embarquer les fontes uniquement au format TrueType, sans exception.
`gui`	`#f`	Travaille silencieusement, et redirige tout le verbiage dans un fichier journal.

Note à l’attention des utilisateurs de Windows : toutes les informations concernant le traitement apparaissent au fur et à mesure dans l’interpréteur de commandes lorsque vous lancez le programme lilypond.exe, à l’inverse de lilypond-windows.exe qui vous renvoie simplement la main. L’option ‘-dgui’ vous permettra alors de rediriger ces informations dans un fichier journal.

`help`	`#f`	Affiche cette aide.
`include-book-title-preview`	`#t`	Inclut les titres de l’ouvrage dans les images de prévisualisation.
`include-eps-fonts`	`#t`	Inclut les fontes dans chaque fichier EPS contenant un système.
`include-settings`	`#f`	Inclut un fichier contenant les réglages globaux. Ce fichier sera inclus avant traitement de la partition.
`job-count`	`#f`	Traite plusieurs fichiers en parallèle, selon le nombre de jobs.
`log-file`	`#f [fichier]`	Fournir `TOTO` en second argument redirigera la sortie dans le fichier journal `TOTO.log`.
`max-markup-depth`	`1024`	Profondeur maximale de l’arborescence de markups. Si un markup était plus profond, part du principe qu’on aboutira pas, émet un avertissement et renvoie alors un markup vide.
`midi-extension`	`"midi"`	Détermine l’extension par défaut des fichiers MIDI, selon la chaîne donnée en argument.
`music-strings-to-paths`	`#f`	Convertit les chaînes textuelles en chemins lorsque les glyphes font partie d’une fonte musicale.
`paper-size`	`\"a4\"`	Détermine la taille par défaut du papier. Veillez à ne pas oublier d’encadrer la valeur par des guillemets échappés (`\"`).
`pixmap-format`	`png16m`	Détermine le format de sortie en images pixélisées pour Ghostscript.
`point-and-click`	`#t`	Ajoute les liens « point & click » à la sortie PDF ou SVG. Voir Pointer-cliquer.
`preview`	`#f`	Génère une prévisualisation en plus de la sortie normale.

Cette option, disponible dans tous les formats de sortie imprimables – pdf, png, ps, eps et svg – génère un fichier de la forme monFichier.preview.extension comprenant le titrage et le premier système. S’il existe plusieurs sections \book, \bookpart, ce fichier contiendra les titrage et premier système de chacun des \book, \bookpart et \score, dès lors que la variable print-all-headers du bloc \paper est activée.

Pour l’éviter, utilisez conjointement l’une des options ‘-dprint-pages’ ou ‘-dno-print-pages’ selon vos besoins.

`print-pages`	`#t`	Génère l’intégralité des pages de la partition. L’option ‘`-dno-print-pages`’ est particulièrement utile lorsqu’utilisée conjointement avec l’option ‘`-dpreview`’.
`profile-property-accesses`	`#f`	Enregistre des statistiques des appels à la fonction `get_property()`.
`protected-scheme-parsing`	`#t`	Continue en dépit des erreurs que l’analyseur syntaxique détecterait dans du code Scheme inclus. Lorsque basculé sur `#f`, stoppe le traitement s’il y a erreur et affiche une trace de la pile.
`read-file-list`	`#f [fichier]`	Spécifie un fichier listant les différents fichiers sources à traiter.
`relative-includes`	`#f`	Face à une instruction `\include`, recherche les fichiers à inclure relativement à l’endroit où se trouve le fichier en cours de traitement plutôt que par rapport au fichier maître.
`resolution`	`101`	Détermine, en `dpi`, la résolution des pixmaps `PNG` à générer selon la valeur donnée.
`safe`	`#f`	Ne pas avoir une confiance aveugle dans le code ‘`.ly`’.

Lorsque LilyPond est accessible au travers d’un serveur web, il est impératif d’utiliser les options ‘--safe’ ou ‘--jail’. L’option ‘--safe’ aura pour effet d’empêcher tout code Scheme inclus de mettre en péril votre installation grâce à quelque chose du style

#(s ystem "rm -rf /") % trop dangeureux à écrire sans faute
{
  c4^$(ly:gulp-file "/etc/passwd") % malveillant mais pas destructeur
}

L’option -dsafe forcera l’évaluation, au fil de l’eau et par un module sécurisé, des expressions Scheme contenues dans le fichier source. Ce module sécuritaire, dérivé du module GUILE ‘safe-r5rs’, ajoute un certain nombre de fonctions – listées dans ‘scm/safe-lily.scm’ – à l’API de LilyPond.

De plus, le mode safe ne permet ni l’utilisation de directives \include ni le recours aux obliques inversées (backslash) dans les chaînes TeX. L’import de variables LilyPond dans du code Scheme n’est pas possible en mode sécurisé.

L’option -dsafe ne détecte pas l’utilisation abusive des ressources. Il est donc possible que le programme finisse par rester sans réponse si on lui envoie une boucle sans fin. C’est la raison pour laquelle nous recommandons, lorsque LilyPond tourne sur un serveur accessible au public, d’en limiter aussi bien les ressources processeur que mémoire.

Notez bien que l’utilisation du mode sécuritaire empêchera aussi la compilation d’un certain nombre de fragments LilyPond. L’option --jail est dans ce cas une excellente alternative en terme de sécurité, même si elle requiert plus de temps à mettre en place – voir Options basiques de lilypond.

`separate-log-files`	`#f`	Pour les fichiers `FICHIER1.ly`, `FICHIER2.ly`, etc. enregistre le déroulement dans les journaux `FICHIER1.log`, `FICHIER2.log`…
`show-available-fonts`	`#f`	Liste le nom des fontes disponibles.
`strict-infinity-checking`	`#f`	Force le crash en présence des points d’exception de virgule flottante `Inf` ou `NaN` – infini ou non-nombre.
`strip-output-dir`	`#t`	Supprime, lors du nommage des fichiers résultant, la partie correspondant au répertoire des fichiers sources.
`strokeadjust`	`#f`	Force l’ajustement des traits PostScript. Cette option trouve toute son utilité pour générer du PDF à partir de PostScript – l’ajustement des traits est en principe automatiquement activé pour les périphériques bitmap à faible résolution. Sans cette option, les visionneurs de PDF ont tendance à ne pas rendre de manière constante l’épaisseur des hampes dans les résolutions habituelles des écrans. Bien que n’affectant pas notoirement la qualité d’impression, cette option accroit notablement la taille des fichiers PDF.
`svg-woff`	`#f`	Cette option est obligatoire dès lors que sont utilisées, avec le moteur SVG, les fontes Web Open Font Format (WOFF). Un fichier SVG sera généré pour chacune des pages produites. En dehors des glyphes musicaux propres à LilyPond, aucune autre information ne sera incluse. Quelque soir le visionneur de SVG utilisé, il devra avoir à disposition les fontes requises pour pouvoir afficher les éléments textuels et les paroles. Dans la mesure où le visionneur pourrait ne pas savoir le gérer, mieux vaut s’abstenir derecourir aux alias ou listes de fontes. Lorsque celles-ci sont utilisées correctement, nul n’est besoin d’installer les fontes que les fichiers SVG utiliseront dans l’environnement du visionneur. Néanmoins, LilyPond ne dispose pas de fichier de fonte `woff` textuelle. La présence du fichier de fonte `woff` est un prérequis.
`trace-memory-frequency`	`#f`	Enregistre l’utilisation de la cellule Scheme plusieurs fois par seconde, dans les fichiers `FICHIER.stacks` et `FICHIER.graph`.
`trace-scheme-coverage`	`#f`	Enregistre la couverture des fichiers Scheme dans `FILE.cov`.
`verbose`	`#f`	Passe en mode verbeux, ce qui correspond à un niveau de journalisation `DEBUG` (lecture seule).
`warning-as-error`	`#f`	Considère tous les messages d’avertissement et « erreur de programmation » comme étant de véritables erreurs.

[ << Exécution de lilypond ]	[Racine][Table des matières][Index][ ? ]			[ Mise à jour avec convert-ly >> ]
[ < Options avancées de lilypond ]		[ Plus haut: Utilisation en ligne de commande ]	[ Exécution de LilyPond en mode protégé > ]

Variables d’environnement

lilypond reconnaît les variables d’environnement suivantes :

LILYPOND_DATADIR: Cette variable spécifie le répertoire où seront recherchés par défaut les différentes versions des messages ainsi qu’un certain nombre de fichiers nécessaires au traitement. Il devrait contenir les sous-répertoires ‘ly/’, ‘ps/’, ‘tex/’, etc.
LANG: Cette variable détermine la langue dans laquelle seront émis les messages.
LILYPOND_LOGLEVEL: Cette variable détermine le niveau par défaut de verbosité. En l’absence de niveau explicite – autrement dit la ligne de commande ne comporte pas de ‘--loglevel’ – c’est cette valeur qui sera utilisée.
LILYPOND_GC_YIELD: Cette variable permet d’ajuster l’empreinte mémoire et le rendement de la machine. Il s’agit en fait d’un pourcentage d’allocation de mémoire : lorsqu’il est élevé, le programme favorisera l’utilisation de la mémoire ; une faible valeur consommera plus de temps processeur. Par défaut, cette valeur est fixée à 70.

[ << Exécution de lilypond ]	[Racine][Table des matières][Index][ ? ]			[ Mise à jour avec convert-ly >> ]
[ < Variables d'environnement ]		[ Plus haut: Utilisation en ligne de commande ]	[ Messages d'erreur > ]

Exécution de LilyPond en mode protégé

Paramétrer un serveur afin qu’il puisse faire fonctionner LilyPond en mode protégé sur un pseudo-périphérique est une tâche sensible. Les différentes étapes à suivre sont répertoriées ci-dessous. Les exemples qu’elle comportent proviennent d’une distribution GNU/Linux Ubuntu et nécessiteront l’utilisation de sudo autant que de besoin.

Installation des paquetages nécessaires : LilyPond, Ghostscript et ImageMagick.
Création de l’utilisateur lily :
```
adduser lily
```
Ceci, par la même occasion, créera un groupe spécifique pour l’utilisateur lily ainsi que son répertoire personnel /home/lily.
Création, dans le répertoire personnel de l’utilisateur lily, d’un espace agissant en tant que système de fichiers :
```
dd if=/dev/zero of=/home/lily/loopfile bs=1k count= 200000
```
Cette commande a créé un fichier de 200 MB utilisable par le « système protégé ».

Création d’un pseudo-périphérique, génération d’un système de fichiers et chargement de celui-ci, puis création d’un répertoire accessible en écriture pour l’utilisateur 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

Affectation, au niveau configuration du serveur, de /mnt/lilyloop en tant que JAIL et /lilyhome en tant que DIR.

Création d’une arborescence, dans l’espace protégé, et recopie de tous les fichiers nécessaires – voir le script plus loin.

Le recours à l’utilitaire sed permet de créer les commandes de copie de tout ce qui est nécessaire à un exécutable :

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

Exemple de script fonctionnel en 32-bit sur Ubuntu 8.04

#!/bin/sh
## les réglages par défaut

username=lily
home=/home
loopdevice=/dev/loop0
jaildir=/mnt/lilyloop
# le préfixe (sans slash au début !)
lilyprefix=usr/local
# le répertoire du système où lilypond est installé
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

# la formule magique de recopie des bibliothèques
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

# les fichiers partagés pour ghostscript...
      cp -L -r /usr/share/ghostscript usr/share
# les fichiers partagés pour ImageMagick
      cp -L -r /usr/lib/ImageMagick* usr/lib

### Partant du principe que test.ly est dans /mnt/lilyloop/lilyhome,
### on devrait pouvoir lancer :
### Attention : /$lilyprefix/bin/lilypond est un script qui
### définit LD_LIBRARY_PATH - c'est primordial
      /$lilyprefix/bin/lilypond -jlily,lily,/mnt/lilyloop,/lilyhome test.ly

Notes de bas de page

[1] Le statut de GUILE n’étant pas réinitialisé après traitement d’un fichier ‘.ly’, veillez à ne pas modifier les réglages par défaut du système à partir d’assertions en Scheme.

[ << Exécution de lilypond ]	[Racine][Table des matières][Index][ ? ]			[ Mise à jour avec convert-ly >> ]
[ < Variables d'environnement ]		[ Plus haut: Utilisation en ligne de commande ]	[ Messages d'erreur > ]

Autres langues : English, català, deutsch, español, magyar, italiano, 日本語.
About automatic language selection.

Lancement de LilyPond
Options basiques de `lilypond`
Options avancées de `lilypond`
Variables d’environnement
Exécution de LilyPond en mode protégé