GNU LilyPond Programmbenutzung: 1.2 Benutzung auf der Kommandozeile

## 1.2 Benutzung auf der Kommandozeile

Dieser Abschnitt enthält zusätzliche Informationen, wie Sie LilyPond von der Kommandozeile ausführen können. Dies kann erforderlich sein, um etwa zusätzliche Optionen an das Programm zu übergeben. Außerdem sind einige Zusatzprogramme (wie etwa `midi2ly`) nur von der Kommandozeile verfügbar.

Unter ‚Kommandozeile‘ verstehen wir die Kommandozeile des jeweiligen Betriebssystems. Windows Benutzern ist sie vielleicht eher unter den englischen Begriffen ‚DOS shell‘ oder ‚command shell‘ bekannt. MacOS X Benutzer kennen sie eher unter ‚Terminal‘ oder ‚Konsole‘.

Wie die Kommandozeile im jeweiligen Betriebssystem benutzt werden kann, soll in diesem Handbuch nicht näher beschrieben werden. Sehen Sie bitte im Handbuch Ihres Betriebssystems nach oder informieren Sie sich im Internet, wenn Sie mit der Kommandozeile nicht vertraut sind.

### `lilypond` aufrufen

Das `lilypond` Programm kann folgendermaßen von der Kommandozeile aufgerufen werden.

>     lilypond [Option]… Dateiname…

Wird ein ‘`Dateiname`’ ohne Erweiterung angegeben, so wird ‘`.ly`’ als Standarderweiterung für LilyPond-Dateien benutzt. Um Daten von `stdin` einzulesen, benutzen Sie einfach einen Bindestrich (`-`) als Dateiname.

Wenn LilyPond die Datei ‘`Dateiname.ly`’ verarbeitet, werden daraus die Dateien ‘`Dateiname.ps`’ und ‘`Dateiname.pdf`’ erzeugt. Es können an `lilypond` auch mehrere ‘`.ly`’ Dateien übergeben werden, die dann einzeln und voneinander unabhängig abgearbeitet werden.1

Falls ‘`Dateiname.ly`’ mehr als eine `\book`-Umgebung enthält, werden die weiteren Stücke in durchnummerierte Dateien der Form ‘`Dateiname-1.pdf`’ ausgegeben. Zusätzlich wird der Wert der Variable `output-suffix` zwischen den ursprünglichen Dateinamen und der Zahl eingefügt. Eine LilyPond-Datei ‘`Dateiname.ly`’ mit dem Inhalt

>     #(define output-suffix "Geige")
>     \score { … }
>     #(define output-suffix "Cello")
>     \score { … }

erzeugt daher die Dateien Dateiname‘`-Geige.pdf`’ und Dateiname‘`-Cello-1.pdf`’.

#### Häufige Kommandozeilenbefehle

Wenn Ihre Kommandozeile normale Weiterleitungen unterstützt, können Sie es nützlich finden, mit folgenden Befehlen die Ausgabe der Kommandozeile in eine Datei zu leiten:

- `lilypond file.ly 1>stdout.log` um normale Ausgabe zu erhalten
- `lilypond file.ly 2>stderr.log` um Fehlermeldungen zu erhalten
- `lilypond file.ly &>all.log` um alle Meldungen zu erhalten

Wenden Sie sich an die Dokumentation für Ihre Kommandozeile, um zu sehen, ob derartige Optionen unterstützt werden oder die Syntax unterschiedlich ist. Beachten Sie, dass es sich hier um reine Verwaltungsprogramme handelt, die nichts mit LilyPond zu tun haben.

### Grundlegende Optionen auf der Kommandozeile für LilyPond

Die folgenden Kommandozeilenoptionen werden von `lilypond` unterstützt:

`-d, --define-default=Variable=Wert`

  Siehe Fortgeschrittene Optionen auf der Kommandozeile für LilyPond.

`-e, --evaluate=expr`

  Wertet den Scheme-Ausdruck expr aus, bevor die ‘`.ly`’ Dateien gelesen und interpretiert werden. Die `-e` Option kann auch mehrfach angegeben werden, die Ausdrücke werden nacheinander ausgewertet.

  Da der Ausdruck im `guile-user` Modul ausgewertet wird, ist bei der Definitionen innerhalb von expr folgendes Vorgehen nötig. An der Kommandozeile wird z.B. `a` im `guile-user` Modul definiert:

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

  Am Beginn der ‘`.ly`’-Datei muss dann das `guile-user` Modul noch geladen werden, bevor die Definition von a verfügbar ist:

  >     #(use-modules (guile-user))

  Achtung: Windows-Benutzer müssen doppelte anstelle der einfachen Anführungsstriche einsetzen.

`-E. --eps`

  Erzeugt EPS-Dateien.

`-f, --format=Format`

  Bestimmt das Ausgabeformat. Mögliche Werte von Format sind `svg`, `ps`, `pdf` und `png`.

  Beispiel: `lilypond -fpng Dateiname.ly`

`-h, --help`

  Zeigt eine Zusammenfassung der Programmbenutzung und der Optionen.

`-H, --header=FELD`

  Gibt den Inhalt eines Feldes aus dem `\header`-Block in die Datei ‘`Dateiname.FELD`’ aus.

`-i, --init=Initialisierungsdatei`

  Benutzt Initialisierungsdatei zur gesamten Programminitialisierung. Der Standardwert ist ‘`init.ly`’.

`-I, --include=Verzeichnis`

  Fügt Verzeichnis zur Liste der Suchpfade hinzu.

  Mehrere -I-Optionen können angegeben werden. Die Suche beginnt mit dem ersten definierten Verzeichnis und setzt in den weiteren Verzeichnissen fort, wenn die gesuchte Datei nicht in dem Verzeichnis gefunden wird.

`-j, --jail=Benutzer,Gruppe,Jail-Verzeichnis,Arbeitsverzeichnis`

  Führt `lilypond` in einem chroot-Jail aus.

  Die ‘`--jail`’ Option ist eine flexiblere Alternative zu ‘`-dsafe`’, wenn LilyPond über das Internet verfügbar gemacht wird oder LilyPond Befehle ausführt, die aus externe Quellen stammen (siehe Fortgeschrittene Optionen auf der Kommandozeile für LilyPond).

  Sie funktioniert dergestalt, dass das Wurzelverzeichnis von `lilypond` auf Jail-Verzeichnis gesetzt wird, bevor die tatsächliche Kompilierung der ‘`.ly`’-Datei beginnt. Der Benutzer und die Gruppe werden auf die angegebenen Werte gesetzt und das aktuelle Arbeitsverzeichnis wird ebenfalls auf den angegebenen Wert Arbeitsverzeichnis gesetzt. Diese Einstellungen garantieren (zumindest in der Theorie), dass es nicht möglich ist, aus dem Jail auszubrechen. Damit ‘`--jail`’ funktioniert, muss `lilypond` allerdings als root ausgeführt werden, was normalerweise auf sichere Art mit dem Kommando `sudo` erreicht werden kann.

  Das Jail-Verzeichnis zu erstellen ist etwas heikel, da LilyPond alle zur Ausführung nötigen Bibliotheken und Dateien innerhalb des Jail-Verzeichnisses finden muss. Ein typisches Setup besteht aus folgenden Punkten:

  Erstellung eines getrennten Dateisystems

    Ein eigenes Dateisystem muss für LilyPond erstellt werden, sodass es mit sicheren Einstellungen wie `noexec`, `nodev` und `nosuid` eingebunden werden kann. Damit ist es unmöglich, Programme von diesem Dateisystem auszuführen oder direkt auf eine Hardware-Schnittstelle zuzugreifen. Wenn Sie keine eigene Partition erstellen möchten, können Sie auch eine Datei der entsprechenden Größe erstellen und sie als ‚loop‘-Gerät einbinden. Ein getrenntes Dateisystem garantiert auch, dass LilyPond nicht mehr Festplattenspeicher benutzt als erlaubt.

  Erstellung eines eigenen Benutzerkontos

    Es sollte ein eigener Benutzer und eine eigene Gruppe (z. B. `lily`/`lily`) mit geringen Rechten für die Ausführung von LilyPond innerhalb des Jails benutzt werden. Nur ein einziges Verzeichnis des Jails sollte für den Benutzer schreibbar sein und als Arbeitsverzeichnis an `lilypond` übergeben werden.

  Einrichtung des Jails

    LilyPond muss zahlreiche Dateien für die Ausführung einlesen. All diese Dateien müssen in das Jail-Verzeichnis kopiert werden (mit denselben Pfaden wie im tatsächlichen Wurzel-Dateisystem). Die gesamte LilyPond-Installation (typischerweise ‘`/usr/share/lilypond`’) sollte kopiert werden.

    Falls Probleme auftreten, ist es am einfachsten, LilyPond mittels `strace` zu starten, wodurch Sie relativ leicht feststellen können, welche Dateien im Jail noch fehlen.

  Ausführung von LilyPond

    In einem mit `noexec` eingebundenen Jail ist es nicht möglich, externe Programme auszuführen. Daher muss LilyPond auf eine Art gestartet werden, die keine weitere Ausführung von Programmen benötigt. Wie bereits erwähnt muss LilyPond mit Administrator-Rechten gestartet werden (die es allerdings sofort wieder abgibt), beispielsweise mittels `sudo`. Außerdem ist es eine gute Idee, die LilyPond zur Verfügung stehende CPU-Zeit zu limitieren (z. B. mit `ulimit -t`) und – falls das Betriebssystem dies unterstützt – auch den zur Verfügung stehenden Hauptspeicher. Siehe auch LilyPond in chroot-Kerker

`-l, --loglevel=Logstufe`

  Passt die Ausführlichkeit der Ausgabe auf der Kommandozeile entsprechend Logstufe an. Mögliche Werte sind:

  `NONE`

    Keine Ausgabe, nicht einmal Fehlermeldungen.

  `ERROR`

    Nur Fehlermeldungen, keine Warnungen oder Fortschrittsmeldungen.

  `WARN`

    Warnungen und Fehlermeldungen, keine Fortschrittsmeldungen.

  `BASIC_PROGRESS`

    Grundlegende Fortschrittsmeldungen (Erfolg), Warnungen und Fehler.

  `PROGRESS`

    Alle Fortschrittsmeldungen, Warnungen und Fehler.

  `INFO (Standard)`

    Fortschrittmeldungen, Warnungen, Fehlermeldungen und weiter Information über die Ausführung.

  `DEBUG`

    Alle möglichen Meldungen, die auch mit der Fehlersuche (Debug) zu tun haben können.

`-o, --output=DATEI oder ORDNER`

  Schreibt das Ergebnis der Verarbeitung mit LilyPond in die Ausgabedatei DATEI. Wenn ein Verzeichnis mit dem Namen existiert, werden die Ausgabedateien in dieses Verzeichnis gespeichert, wobei der Dateiname der Eingabedatei benutzt wird. Die entsprechende Dateinamenserweiterung wird angehängt (z.B. `.pdf` für pdf).

`-O, --pspdfopt`

  Wird diese Option nicht oder mit dem Parameter `size` verwendet, wird eine Art der Erzeugung von Postscript- EPS- bzw. PDF-Dateien gewählt, die möglichst kleine Dateien erzeugt.

  Der Parameter `TeX` führt zu Dateien, die besonders gut zur Einbindung in pdfTeX, LuaTeX oder XeTeX geeignet sind.

  Sollen mehrere mit LilyPond erzeugt Dokumente in ein TeX-Dokument eingebunden werden, so bietet es sich an, `TeX-GS` zu verwenden und das von TeX erzeugte PDF noch einmal mit Ghostscript zu bearbeiten.

`--ps`

  Erzeugt PostScript.

`--png`

  Erzeugt eine Grafik-Datei im PNG-Format von jeder Seite. Diese Option impliziert auch `--ps`. Die Auflösung in DPI der Grafik kann festgelegt werden durch

  >     -dresolution=110

`--pdf`

  Erzeugt PDF-Dateien. Dies impliziert `--ps`.

`-v, --version`

  Gibt die Versionsnummer aus.

`-V, --verbose`

  Gibt ausführliche informative Meldungen aus: Zeigt die vollen Dateipfade aller gelesenen Dateien sowie Informationen über die Laufzeit.

`-w, --warranty`

  Zeigt die Garantiebedingungen an, unter denen GNU LilyPond steht. (Es besteht KEINERLEI GARANTIE!)

### Fortgeschrittene Optionen auf der Kommandozeile für LilyPond

`-d[Optionsbezeichnung]=[Wert],--define-default=[Optionsbezeichnung]=[Wert]`

  Hiermit wird die entsprechende interne Scheme-Funktion auf den Wert gesetzt. Wenn kein value angegeben wird, wird der Standardwert eingesetzt. Die Vorsilbe `no-` kann zur Optionsbezeichnung hinzugefügt werden, um eine Funktion „auszuschalten“. Beispielsweise

  >     -dpoint-and-click=#f

  ist das gleiche wie

  >     -dno-point-and-click

Folgende Optionen sind mit ihren entsprechenden Standardwerten unterstützt:

Symbol | Wert | Erklärung/Optionen
`anti-alias-factor` | `1` | Die Bilder in einer höheren Auflösung rendern (Faktor angegeben) und das Resultat herunterrechnen, um „Zacken“ in `PNG`-Bildern zu vermeiden.
`aux-files` | `#t` | Erstelle `.tex`, `.texi`, `.count`-Dateien im `EPS`-Backend.
`backend` | `ps` | Auswahl des Backend. Poststscript-Dateien (Standart) enthalten `TTF`, `Type1` und `OTF`-Schriftarten. Ihr Zeichenvorrat wird nicht reduziert (Subsetting). Die Benutzung von östlichen Schriftarten kann zu sehr großen Dateien führen.
| `svg` | Scalable Vector Graphics. Hiermit wird eine einzelne `SVG`-Datei für jede Seite der Ausgabe erstellt, ohne Schriftarten. Es wird empfohlen, die Century Schoolbook-Schriftarten zu installieren, welche mit der LilyPond-Installation mitkommen, um optimales Rendern zu erreichen. Unter UNIX kann man einfach die Schriftartdateien aus dem LilyPond-Verzeichnis (üblicherweise ‘`/usr/share/lilypond/VERSION/fonts/otf/`’) nach ‘`~/.fonts/`’. Die `SVG`-Ausgabe sollte mit allen SVG-Programmen oder -Editoren kompatibel sein. Es gibt auch die Option `svg-woff` (siehe unten) um woff-Schriftarten im SVG-Backend zu benützen.
`clip-systems` | `#f` | Erstelle ausgeschnittene Schnipsel einer Partitur.
`datadir` |  | Präfix für Datendateien (read-only).
`debug-skylines` | `#f` | Debugging von Skylines.
`delete-intermediate-files` | `#t` | Entferne unbenutzbare, zwischenzeitliche `.ps`-Dateien, die während der Kompilations erstellt werden.
`eps-box-padding` | `#f` | Verschiebe die linke Ecke der ausgegebenen EPS-Boundingbox um die angegebene Entfernung (in mm).
`gs-load-fonts` | `#f` | Lade die Schriftarten durch Ghostscript.
`gs-load-lily-fonts` | `#f` | Lade nur die LilyPond-Schriftarten durch Ghostscript.
`help` | `#f` | Zeige die Hilfe.
`include-book-title-preview` | `#t` | Füge Titel eines Buches (book) in die Vorschaubilder ein.
`include-eps-fonts` | `#t` | Füge Schriftarten in EPS-Dateien von einzelnen Systemen ein.
`include-settings` | `#f` | Füge eine Datei für globale Einstellungen ein, dieses wird gelesen, bevor die Partitur verarbeitet wird.
`job-count` | `#f` | Bearbeite Dateien parallel, mit der angegebenen Anzahl von Prozessen.
`log-file` | `#f [file]` | Wenn die Zeichenkette `FOO` als ein zweites Argument angegeben wird, wird die Ausgabe in die Log-Datei `FOO.log` umgeleitet.
`max-markup-depth` | `1024` | Maximale Tiefe eines Beschriftungs-(markup)-Baumes. Wenn eine Beschriftung mehr Ebenen hat, wird angenommen, dass die Beschriftung nicht von sich aus schließt, eine Warnung ausgegeben und eine leere Beschriftung gesetzt.
`midi-extension` | `"midi"` | Schreibe als Standarddateierweiterung für MIDI die angegebene Zeichenkette.
`music-strings-to-paths` | `#f` | Konvertiere Textzeichenketten in Pfade, wenn die Glyphen einer Musik-Schriftart gehören.
`old-relative` | `#f` | Lässt den `\relative`-Modus für simultane Musik ähnlich wie die Akkord-Syntax funktionieren.
`paper-size` | `\"a4\"` | Stelle die Standardpapiergröße ein. Beachten Sie, dass die Zeichenkette von doppelten Anführungszeichen mit Backslash umgeben werden muss.
`pixmap-format` | `png16m` | Stellt das Ausgabeformat von GhostScript für Pixel-Bilder ein.
`point-and-click` | `#f` | Füge ‚point & click‘-Links in die `PDF`-Ausgabedatei ein. Siehe auch Point and click.
`preview` | `#f` | Erstelle Vorschaubilder zusätzlich zur normalen Ausgabe.

Diese Option wird von allen Backends unterstützt: `pdf`, `png`, `ps`, `eps` und `svg`, allerdings nicht `scm`. Hiermit wird eine Ausgabedatei in der Form `meineDatei.preview.Dateierweiterung` erstellt, die die Titel und das erste Notensystem enthält. Wenn `\book`- oder `\bookpart`-Umgebungen inegesetzt werden, werden die Titel von `\book`, `\bookpart` oder `\score` in die Ausgabe aufgenommen, sowie das erste System jeder `\score`-Umgebung, wenn die Variable `print-all-headers` in der `paper`-Umgebung auf `#t` eingesetllt ist.

Um die normale Ausgabe zu unterdrücken, können die Optionen ‘`-dprint-pages`’ oder ‘`-dno-print-pages`’ eingesetzt werden.

`print-pages` | `#t` | Erstelle vollständige Seiten, der Standard. ‘`-dno-print-pages`’ ist hilfreich im Zusammenhang mit ‘`-dpreview`’.
`protected-scheme-parsing` | `#t` | Fahre fort, wenn Fehler in eingefügtem Scheme-Code im Parser bemerkt werden. Wenn auf `#f` gesetzt, halte an Fehlern an und gebe einen Stacktrace aus.
`relative-includes` | `#f` | Wenn ein `\include`-Befehl bearbeitet wird, suche nach der eingefügten Datei relativ zur aktuellen Datei (und nicht relativ zur untersten Ebene).
`resolution` | `101` | Setzt die Auflösung, mit der `PNG`-Bilder erstellt werde, auf einen bestimmten Wert (in dpi).
`safe` | `#f` | Der `.ly`-Eingabe nicht trauen.

Wenn LilyPond-Notensatz über einen Webserver zur Verfügung gestellt wird, müssen entweder die Option ‘`--safe`’ oder die Option ‘`--jail`’ mitgegeben werden. Die Option ‘`--safe`’ verhindert eingefügten Scheme-Code daran, Schaden auszuüben, etwa

>     #(system "rm -rf /")
>     {
>       c4^$(ly:gulp-file "/etc/passwd")
>     }

Die Option ‘`-dsafe`’ interpretiert eingefügte Scheme-Ausdrücke in einem besonderen sicheren Modul. Das ist aus dem GUILE ‘`safe-r5rs`’-Modul abgeleitet, fügt aber einige Funktionen der LilyPond API hinzu, welche sich in ‘`scm/safe-lily.scm`’ aufgelistet finden.

Zusätzliche verbietet der sichere Modus `\include`-Befehle und stellt die Benutzung von Backslash in TeX-Zeichenketten aus. Im sicheren Modus ist es auch nicht möglich, LilyPond-Variablen in Scheme zu importieren.

‘`-dsafe`’ kann jedoch nicht Überbenutzung von Resourcen entdecken, sodass man trotzdem das Programm abschießen kann, etwa indem man eine sich wiederholende Datenstruktur in das Backend leitet. Darum sollte LilyPond sowohl in der CPU- als auch Speicherbenutzung eingeschränkt betrieben werden, wenn es über einen Webserver öffentlich zugänglich gemacht wird.

Der sichere Modus verhindert die Kompilierung von vielen nützlichen LilyPond-Schnipseln.

die Option ‘`--jail`’ ist noch sicherer, erfordert aber mehr Arbeit beim Setup. Siehe auch Grundlegende Optionen auf der Kommandozeile für LilyPond.

`separate-log-files` | `#f` | Für Eingabedateien `Datei1.ly`, `Datei2.ly` usw. die Log-Daten in die Dateien `Datei1.log`, `Datei2.log` ... schreiben.
`show-available-fonts` | `#f` | Eine Liste der verfügbaren Schriftarten.
`strip-output-dir` | `#t` | Verzeichnisse von Eingabedateien nicht in die Konstruktion der Ausgabedateinamen einbeziehen.
`svg-woff` | `#f` | Woff-Schriftarten im SVG-Backend benuützen..
`verbose` | `#f` | Ausfühliche Ausgabe, also Logstufe DEBUG (read-only).
`warning-as-error` | `#f` | Alle Warnungen und ‚Programmierfehler‘-Nachrichten in Fehler ändern.

### Umgebungsvariablen

`lilypond` erkennt und benützt die folgenden Umgebungsvariablen:

`LILYPOND_DATADIR`

  Diese Variable gibt das Verzeichnis an, wo LilyPond seine eigenen Dateien, Meldungen und Übersetzungen finden kann. Dieses Verzeichnis sollte Unterverzeichnisse ‘`ly/`’, ‘`ps/`’, ‘`tex/`’, etc. beinhalten.

`LANG`

  Gibt die Sprache an, in der Warnungen und Fehlermeldungen ausgegeben werden.

`LILYPOND_LOGLEVEL`

  Die standardmäßige Logstufe. Wenn LilyPond ohne eine explizite Logstufe aufterufen wird (d. h. die Kommandozeilenoption ‘`--loglevel`’ nicht eingesetzt wird), wird dieser Wert benutzt.

`LILYPOND_GC_YIELD`

  Eine Variable (von 1 bis 100), die die Speicherverwaltung regelt. Bei niedrigeren Werten wird mehr Prozessor-Zeit, dafür weniger Hauptspeicher benötigt. Voreinstellung ist ein Wert von `70`.

### LilyPond in chroot-Kerker

Einen Server einzurichten, der LilyPond in einem chroot-Kerker bedient, ist recht kompliziert. Die einzelnen Schritten finden sich unten aufgeliestet. Beispiele sind für Ubuntu GNU/Linux und erfordern evtl. die Benutzung von `sudo` an den entsprechenden Stellen.

- Installieren Sie die nötigen Pakete: LilyPond, GhostScript und ImageMagick.
- Erstellen Sie einen neuen Benutzer mit dem Namen `lily`:

  >     adduser lily

  Hierdurch wird auch eine Gruppe `lily` und ein Heimat-Ordner `/home/lily` für den neuen Benutzer erstellt.

- Im Heimat-Ordner des Benutzers `lily` erstellen Sie eine Datei, die als eigenes Dateisystem eingesetzt wird:

  >     dd if=/dev/zero of=/home/lily/loopfile bs=1k count= 200000

  In diesem Beispiel wird eine 200-MB-Datei als Kerker-Dateisystem erstellt.

- Erstellen Sie ein loop device, erstellen Sie ein Dateisystem und mounten Sie es, dann erstellen Sie dort einen Ordner, in dem der Benutzer `lily` Schreibrechte hat:

  >     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

- In der Konfiguration des Servers ist der Kerker (JAIL) `/mnt/lilyloop` und das Verzeichnis (DIR) `/lilyhome`.
- Erstellen Sie einen großen Verzeichnisbaum in dem Kerker, indem Sie die notwendigen Dateien dorthin kopiert, wie das Beispielskript unten zeigt.

  Sie könne `sed` benutzen, um die notwendigen Kopierbefehle für ein bestimmtes Programm zu erstellen:

  >     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

### Beispiel-Skript für 32-bit Ubuntu 8.04

>     #!/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

### Fußnoten

[1] Der Zustand von GUILE wird allerdings nicht nach jeder Datei zurückgesetzt, sodass Achtung geboten ist, wenn in einer Datei globale Änderungen von Scheme aus durchgeführt werden.

#### LilyPond – Usage v2.24.4 (stabiler Zweig).