GNU LilyPond – Utilisation des programmes: 5.5 De la commande make et des fichiers Makefile

## 5.5 De la commande `make` et des fichiers `Makefile`

La plupart des plates-formes sur lesquelles tourne LilyPond disposent d’un logiciel appelé `make`. Ce logiciel va lire un fichier spécial, nommé `Makefile`, qui contient tout ce qu’il faut – les dépendances entre certains fichiers, les instructions successives à traiter par le système – pour aboutir au fichier que vous désirez obtenir. Il pourrait par exemple contenir tout ce qu’il faut pour produire ‘`ballade.pdf`’ et ‘`ballade.midi`’ à partir de ‘`ballade.ly`’ en lançant LilyPond.

La création d’un `Makefile` peut se révéler pertinente pour certains projets, que ce soit par simple goût personnel ou bien par respect de ceux qui pourront accéder à vos sources. Cette manière de procéder est particulièrement indiquée lorsque vous travaillez sur un projet de grande envergure impliquant de nombreuses inclusions de fichiers et différentes éditions – par exemple un conducteur et un matériel d’orchestre complet avec la partition pour le chef et une partition séparée pour chacun des pupitres – ou bien si votre projet requiert certaines commandes particulières comme `lilypond-book`. Les Makefiles varient tant en complexité qu’en flexibilité selon les besoin et les aptitudes de celui qui les crée. Le programme GNU Make est installé par défaut sur les distributions Linux et sur MacOS X, et il en existe une version pour les environnements Windows.

Consultez le GNU Make Manual pour plus de détails sur ce dont `make` est capable – vous pourrez même en trouver des versions françaises à l’aide des moteurs de recherche –, dans la mesure où ce qui suit ne donne qu’un bref apperçu de ses possibilités.

Les commandes permettant de définir les règles diffèrent selon la plate-forme : si les différents Linux et MacOS X utilisent `bash`, Windows utilise `cmd`. Dans le cas de MacOS X, vous devrez toutefois configurer votre système de telle sorte qu’il utilise l’interpréteur en ligne de commande. Voici quelques exemples de fichier Makefile, avec une version pour Linux ou MacOS et une pour Windows.

Pour commencer, une pièce à quatre mouvements pour orchestre et dont les fichiers sont répartis selon l’arborescence suivante :

>     Symphonie/
>     |-- MIDI/
>     |-- Makefile
>     |-- Notes/
>     |   |-- alto.ily
>     |   |-- cor.ily
>     |   |-- cello.ily
>     |   |-- figures.ily
>     |   |-- hautbois.ily
>     |   |-- trioCordes.ily
>     |   |-- violonOne.ily
>     |   `-- violonTwo.ily
>     |-- Partitions/
>     |   |-- symphonie.ly
>     |   |-- symphonieI.ly
>     |   |-- symphonieII.ly
>     |   |-- symphonieIII.ly
>     |   `-- symphonieIV.ly
>     |-- PDF/
>     |-- Pupitres/
>     |   |-- symphon-alto.ly
>     |   |-- symphonie-cello.ly
>     |   |-- symphonie-cor.ly
>     |   |-- symphonie-hautbois.ly
>     |   |-- symphonie-violonUn.ly
>     |   `-- symphonie-violonDeux.ly
>     `-- symphonieDefs.ily

Les fichiers ‘`.ly`’ des répertoires `Partitions` et `Pupitres` récupèreront la notation des fichiers ‘`.ily`’ contenus dans le répertoire `Notes` :

>     %%% début du fichier "symphone-cello.ly"
>     \include ../symphonieDefs.ily
>     \include ../Notes/cello.ily

Le Makefile répertorie des cibles correspondant à `score` (l’intégrale au format conducteur), `mouvements` (chacun des mouvements au format conducteur) et `pupitres` (une partition par pupitre). Il contient aussi une cible `archive` chargée de générer une archive des fichiers source qui pourra être diffusée sur la toile ou transmise par courriel. Voici ce que contiendrait ce Makefile pour Linux ou MacOS X. Ce fichier doit être enregistré sous le nom de `Makefile` à la racine du projet – ici `Symphonie`.

Note : Lorsque vous définissez une cible ou une règle sur plusieurs lignes, les lignes à partir de la deuxième doivent débuter par une tabulation, non pas par des espaces.

>     # Le préfixe au nom des fichiers résultants
>     piece = symphonie
>     # Détermination du nombre de processeurs
>     CPU_CORES=`cat /proc/cpuinfo | grep -m1 "cpu cores" | sed s/".*: "//`
>     # La commande d'appel à lilypond
>     LILY_CMD = lilypond -ddelete-intermediate-files \
>                         -dno-point-and-click -djob-count=$(CPU_CORES)

>     # Les suffixes utilisés dans ce Makefile
>     .SUFFIXES: .ly .ily .pdf .midi

>     # Les fichiers sources et résultants sont recherchés dans les répertoires
>     # listés dans la variable VPATH.  Ceux-ci sont tous des sous-répertoires
>     # du répertoire courant (fourni par la variable de GNU make `CURDIR').
>     VPATH = \
>       $(CURDIR)/Partitions \
>       $(CURDIR)/PDF \
>       $(CURDIR)/Pupitres \
>       $(CURDIR)/Notes

>     # La règle type pour créer un PDF et un MIDI à partir d'un fichier
>     # source LY.
>     # Les .pdf résultants iront dans le sous-répertoire "PDF" et les fichiers
>     # .midi dans le sous-répertoire "MIDI".
>     %.pdf %.midi: %.ly
>             $(LILY_CMD) $<; \           # cette ligne commence par une tabulation
>             if test -f "$*.pdf"; then \
>                 mv "$*.pdf" PDF/; \
>             fi; \
>             if test -f "$*.midi"; then \
>                 mv "$*.midi" MIDI/; \
>             fi

>     notes = \
>       alto.ily \
>       cello.ily \
>       cor.ily \
>       hautbois.ily \
>       violonUn.ily \
>       violonDeux.ily

>     # Les dépendances selon le mouvement.
>     $(piece)I.pdf: $(piece)I.ly $(notes)
>     $(piece)II.pdf: $(piece)II.ly $(notes)
>     $(piece)III.pdf: $(piece)III.ly $(notes)
>     $(piece)IV.pdf: $(piece)IV.ly $(notes)

>     # Les dépendances pour la partition intégrale.
>     $(piece).pdf: $(piece).ly $(notes)

>     # Les dépendances pour les pupitres.
>     $(piece)-alto.pdf: $(piece)-alto.ly alto.ily
>     $(piece)-cello.pdf: $(piece)-cello.ly cello.ily
>     $(piece)-cor.pdf: $(piece)-cor.ly cor.ily
>     $(piece)-hautbois.pdf: $(piece)-hautbois.ly hautbois.ily
>     $(piece)-violonUn.pdf: $(piece)-violonUn.ly violonUn.ily
>     $(piece)-violonDeux.pdf: $(piece)-violonDeux.ly violonDeux.ily

>     # Lancer `make score' pour générer l'intégrale des quatre mouvements en
>     # un seul fichier.
>     .PHONY: score
>     score: $(piece).pdf

>     # Lancer `make parties' pour obtenir tous les pupitres.
>     # Lancer `make toto.pdf' pour obtenir la partie instrumentale de toto.
>     # Par exemple : `make symphonie-cello.pdf'.
>     .PHONY: parties
>     parties: $(piece)-cello.pdf \
>              $(piece)-violonUn.pdf \
>              $(piece)-violonDeux.pdf \
>              $(piece)-alto.pdf \
>              $(piece)-hautbois.pdf \
>              $(piece)-cor.pdf

>     # Lancer `make mouvements' pour générer un fichier séparé pour chacun
>     # des mouvements.
>     .PHONY: mouvements
>     mouvements: $(piece)I.pdf \
>                 $(piece)II.pdf \
>                 $(piece)III.pdf \
>                 $(piece)IV.pdf

>     all: score parties mouvements

>     archive:
>             tar -cvvf symphonie.tar \      # cette ligne commence par une tabulation
>             --exclude=*pdf --exclude=*~ \
>             --exclude=*midi --exclude=*.tar \
>             ../Symphonie/*

Les choses se compliquent sous Windows. Une fois GNU Make pour Windows téléchargé et installé, il vous faudra correctement définir le chemin d’accès au programme Make – dans les variables d’environnement du système – afin que l’interpréteur de commandes DOS puisse le localiser. Pour cela, faites un clic droite sur « Poste de travail », choisissez `Propriétés` puis `Avancées`. Cliquez sur `Variables d'environnement` puis, dans l’onglet `Variables système`, mettez `path` en surbrillance et cliquez sur `Modifier`. Ajoutez alors le chemin d’accès complet à l’exécutable de GNU Make, qui devrait ressembler à :

>     C:\Program Files\GnuWin32\bin

Il va également falloir adapter le makefile aux particularités de l’interpréteur de commandes et à la présence d’espaces dans le nom de certains répertoire de ce système. La cible `archive` est tout bonnement supprimée, puisque Windows ne dispose pas de la commande `tar`. Enfin, les fichiers MIDI ont une extension par défaut propre à Windows.

>     ## VERSION POUR WINDOWS
>     ##
>     piece = symphonie
>     LILY_CMD = lilypond -ddelete-intermediate-files \
>                         -dno-point-and-click \
>                         -djob-count=$(NUMBER_OF_PROCESSORS)

>     #get the 8.3 name of CURDIR (workaround for spaces in PATH)
>     workdir = $(shell for /f "tokens=*" %%b in ("$(CURDIR)") \
>               do @echo %%~sb)

>     .SUFFIXES: .ly .ily .pdf .mid

>     VPATH = \
>       $(workdir)/Partitions \
>       $(workdir)/PDF \
>       $(workdir)/Pupitress \
>       $(workdir)/Notes

>     %.pdf %.mid: %.ly
>             $(LILY_CMD) $<      # cette ligne commence par une tabulation
>             if exist "$*.pdf"  move /Y "$*.pdf"  PDF/ # tabulation au début
>             if exist "$*.mid" move /Y "$*.mid" MIDI/  # tabulation au début

>     notes = \
>       cello.ily \
>       figures.ily \
>       cor.ily \
>       hautbois.ily \
>       trioCordes.ily \
>       alto.ily \
>       violonUn.ily \
>       violonDeux.ily

>     $(piece)I.pdf: $(piece)I.ly $(notes)
>     $(piece)II.pdf: $(piece)II.ly $(notes)
>     $(piece)III.pdf: $(piece)III.ly $(notes)
>     $(piece)IV.pdf: $(piece)IV.ly $(notes)

>     $(piece).pdf: $(piece).ly $(notes)

>     $(piece)-cello.pdf: $(piece)-cello.ly cello.ily
>     $(piece)-cor.pdf: $(piece)-cor.ly cor.ily
>     $(piece)-hautbois.pdf: $(piece)-hautbois.ly hautbois.ily
>     $(piece)-alto.pdf: $(piece)-alto.ly alto.ily
>     $(piece)-violonUn.pdf: $(piece)-violonUn.ly violonUn.ily
>     $(piece)-violonDeux.pdf: $(piece)-violonDeux.ly violonDeux.ily

>     .PHONY: score
>     score: $(piece).pdf

>     .PHONY: parties
>     parties: $(piece)-cello.pdf \
>              $(piece)-violonUn.pdf \
>              $(piece)-violonDeux.pdf \
>              $(piece)-alto.pdf \
>              $(piece)-hautbois.pdf \
>              $(piece)-cor.pdf

>     .PHONY: mouvements
>     mouvements: $(piece)I.pdf \
>                $(piece)II.pdf \
>                $(piece)III.pdf \
>                $(piece)IV.pdf

>     all: score parties mouvements

Le Makefile suivant convient pour un document `lilypond-book` réalisé avec LaTeX. Ce projet contiendra un index, ce qui nécessitera de lancer une deuxième fois `latex` pour mettre à jour les liens. Les fichiers résultants iront dans le répertoire `out` pour ce qui est des .pdf et dans le répertoire `htmlout` pour ce qui est du html.

>     SHELL=/bin/sh
>     FILE=monprojet
>     OUTDIR=out
>     WEBDIR=htmlout
>     VIEWER=acroread
>     BROWSER=firefox
>     LILYBOOK_PDF=lilypond-book --output=$(OUTDIR) --pdf $(FILE).lytex
>     LILYBOOK_HTML=lilypond-book --output=$(WEBDIR) $(FILE).lytex
>     PDF=cd $(OUTDIR) && pdflatex $(FILE)
>     HTML=cd $(WEBDIR) && latex2html $(FILE)
>     INDEX=cd $(OUTDIR) && makeindex $(FILE)
>     PREVIEW=$(VIEWER) $(OUTDIR)/$(FILE).pdf &

>     all: pdf web keep

>     pdf:
>             $(LILYBOOK_PDF)  # tabulation en début de ligne
>             $(PDF)           # tabulation en début de ligne
>             $(INDEX)         # tabulation en début de ligne
>             $(PDF)           # tabulation en début de ligne
>             $(PREVIEW)       # tabulation en début de ligne

>     web:
>             $(LILYBOOK_HTML) # tabulation en début de ligne
>             $(HTML)          # tabulation en début de ligne
>             cp -R $(WEBDIR)/$(FILE)/ ./  # tabulation en début de ligne
>             $(BROWSER) $(FILE)/$(FILE).html &  # tabulation en début de ligne

>     keep: pdf
>             cp $(OUTDIR)/$(FILE).pdf $(FILE).pdf  # tabulation en début de ligne

>     clean:
>             rm -rf $(OUTDIR) # tabulation en début de ligne

>     web-clean:
>             rm -rf $(WEBDIR) # tabulation en début de ligne

>     archive:
>             tar -cvvf monprojet.tar \ # tabulation en début de ligne
>             --exclude=out/* \
>             --exclude=htmlout/* \
>             --exclude=monprojet/* \
>             --exclude=*midi \
>             --exclude=*pdf \
>             --exclude=*~ \
>             ../MonProjet/*

AVENIR: faire que ça marche sous Windows

Ce makefile n’est malheureusement pas opérationnel sous Windows. La seule alternative qui s’offre aux utilisateurs de Windows consiste à créer un fichier de traitement par lot (`.bat`) qui contienne les différentes commandes successives. Bien que cette manière de procéder ne tienne aucun compte des dépendances entre fichiers, elle permet de réduire le nombre de processus à lancer dans une seule commande. Vous devrez enregistrer les lignes suivantes dans un fichier `construire.bat` ou `construire.cmd`. Ce fichier pourra être exécuté soit en ligne de commande, soit par un double clic sur son icone.

>     lilypond-book --output=out --pdf monprojet.lytex
>     cd out
>     pdflatex monprojet
>     makeindex monprojet
>     pdflatex monprojet
>     cd ..
>     copy out\monprojet.pdf MonProjet.pdf

#### Voir aussi

Manuel d’utilisation : Utilisation en ligne de commande, Association musique-texte avec `lilypond-book`

Autres langues : English, deutsch, español, magyar, italiano, 日本語.

#### LilyPond — Utilisation des programmes