1.1 Origine : gérer la fabrication de programmes informatiques

Make a été inventé pour automatiser la fabrication de programmes exécutables. Un programme exécutable est un fichier qui se fabrique en deux temps : d’abord, on écrit du code dans des fichiers texte ; puis on exécute un programme appelé compilateur qui transforme le code en un fichier exécutable – cette deuxième étape, c’est la compilation.

Make a été conçu en particulier pour déterminer quels fichiers doivent être recompilés lors de la fabrication d’un programme. Lorsqu’un fichier est modifié, exécuter Make déclenche automatiquement les commandes appropriées. L’objectif était de ne pas tout recompiler si on ne modifiait qu’une petite partie du code d’un programme complexe, afin d’économiser des ressources et gagner du temps.

Pour faire cela, Make s’appuie sur deux choses : la date de dernière modification des fichiers ; et un arbre de dépendances, c’est-à-dire une représentation des relations entre des fichiers cible, qu’on veut fabriquer, et des fichiers source (les « dépendances »), qui sont nécessaires à la fabrication des fichiers cible. Évidemment, un fichier cible peut à son tour être fichier source pour fabriquer un autre fichier cible, et ainsi de suite.

Voici un exemple d’arbre de dépendances :

Si l’une des dépendances change, Make recompile le ou les fichiers cible correspondants. Dans l’exemple ci-dessus, si one.h est modifié, Make recompile one.cpp puis main.cpp, mais pas two.cpp.

1.2 Fonctionnement : les Makefiles

Le fonctionnement de Make repose sur des fichiers texte appelés Makefiles. Dans un Makefile, on rédige des instructions appelées règles (rules) ; chaque règle définit une recette (recipe) pour fabriquer une ou plusieurs cibles (targets) suivant des prérequis (prerequisites).

Les règles s’écrivent de la manière suivante :

cibles : prérequis
	recette

Ce sont les relations entre cibles et prérequis qui constituent l’arbre de dépendances modélisé par Make.

Une recette est constituée d’une ou plusieurs commandes : des instructions textuelles qu’on exécuterait habituellement dans un terminal.

cibles : prérequis
	commande
	commande
	commande
	…

Comme dans de nombreux langages informatiques, la syntaxe des Makefiles inclut la possibilité de créer des variables, de laisser des commentaires, de définir des fonctions qui incluent des étapes logiques, etc.

Pour exécuter les instructions contenues dans un Makefile, il faut ouvrir un terminal, se déplacer à l’emplacement du Makefile, puis exécuter la commande make (ce qui déclenche les instructions qui sont contenues dans le Makefile).

Si vous souhaitez découvrir comment utiliser un terminal, consultez ma page Ligne de commande.

1.3 Utilisation en dehors du développement logiciel

Progressivement, d’autres usages de Make ont émergé. En effet, son fonctionnement a une portée plus générale que la seule fabrication de programmes, car il ne pose aucune restriction sur la nature de la cible, des prérequis ou de la recette. On peut utiliser Make pour automatiser le déclenchement de n’importe quel programme qui s’utilise habituellement à la ligne de commande.

Donc si Make est souvent présenté comme un outil d’automatisation pour la compilation de programmes, il serait en fait plus juste de le décrire comme un outil d’automatisation pour la ligne de commande. C’est un outil qui permet de définir des enchaînements de commandes textuelles ; dit de façon plus abstraite, Make permet de créer des processus, des séquences d’actions, où chaque action est une instruction envoyée à un ou plusieurs programmes à interface textuelle. Bref : Make permet de fabriquer des fabriques. (Clin d’œil à Antoine Fauchié qui a beaucoup travaillé sur ce concept de fabrique, voir son blog et sa thèse.)

1.4 Outils requis pour utiliser Make

Pour utiliser Make, vous avez besoin des choses suivantes :

Un terminal

Si vous n’êtes pas familier de ce type d’environnement, consultez ma page Ligne de commande.

Le programme Make

Make existe dans plusieurs versions. Cette page est écrite en référence à GNU Make, la version la plus répandue. Sur Linux et macOS, Make est pré-installé ; pour vérifier de quelle version vous disposez, exécutez make --version dans un terminal. Sur Windows, vous pouvez installer Make par exemple en installant le gestionnaire de programmes Chocolatey, puis en utilisant Chocolatey pour installer Make en ouvrant un terminal (je recommande PowerShell) et en exécutant la commande choco install make.

Un éditeur de texte

Pour rédiger des Makefiles. Je recommande souvent Notepad++ (Windows), BBEdit (macOS) et gedit (Linux), mais n’importe quel éditeur de texte fera l’affaire.

2.1 Règles : cibles, prérequis, recettes

Un Makefile contient une ou plusieurs règles.

La syntaxe générale d’une règle est la suivante :

cibles : prérequis
	recette

Les cibles et les prérequis sont des noms de fichiers, séparés par des espaces. En pratique, il n’y a souvent qu’une cible par règle.

La recette est constituée d’une ou plusieurs commandes, qui sont une série d’étapes utilisées pour créer la cible. Make applique la recette :

• si les cibles n’existent pas ;
• si les cibles existent mais que les prérequis ont une date de dernière modification plus récente que les cibles.

doc.pdf : doc.md
	pandoc doc.md -o doc.pdf

2.2 Cibles factices

Les cibles peuvent être des cibles « factices » (en anglais phony). Une cible factice ne correspond pas à un fichier réel : c’est une sorte de nom de code pour une série d’opérations qu’on veut exécuter. Les cibles factices doivent être déclarées comme prérequis de la cible spéciale .PHONY.

.PHONY: all

doc-fr.pdf : doc-fr.md
	pandoc doc-fr.md -o doc-fr.pdf

doc-en.pdf : doc-en.md
	pandoc doc-en.md -o doc-en.pdf

all : doc-fr.pdf doc-en.pdf

2.3 Commentaires

Dans une ligne, le caractère # indique le début d’un commentaire, c’est-à-dire d’une information qui n’est pas destinée à la machine mais à des humains. Tous les caractères qui suivent #, jusqu’à la fin de la ligne, sont ignorés par Make au moment de l’exécution. On utilise généralement les commentaires pour ajouter des explications sur la structure et le fonctionnement du Makefile.

# Un titre qui explique ce qu'est ce Makefile

cible : prérequis
	recette compliquée # commentaire qui explique la recette

Remarque : dans mes exemples, je saute parfois des lignes entre les règles pour plus de confort visuel. Ce n’est ni nécessaire ni signifiant pour le fonctionnement du logiciel : comme pour les commentaires, ce sont des manières d’écrire qui sont là pour faciliter le travail humain.

2.4 Ordre d’exécution des règles

Si un Makefile contient plusieurs règles, par défaut make fabrique la première cible qu’il trouve dans le fichier. Il est possible de définir manuellement la cible à exécuter par défaut grâce à la variable spéciale .DEFAULT_GOAL (voir la section Variables spéciales plus bas).

2.5 Options d’exécution

La commande make dispose de nombreuses options qui modifient son comportement. Utilisez make --option pour appliquer l’option correspondante lors de l’utilisation de Make. Plusieurs options peuvent être utilisées simultanément. La plupart des options sont disponibles sous plusieurs noms (notamment pour des questions de compatibilité), dont des formes raccourcies avec un seul tiret et une seule lettre, pour aller plus vite lorsqu’on saisit les commandes manuellement.

Quelques exemples :

• -n (ou --just-print, --dry-run, --recon) : affiche les commandes qui seraient exécutées, sans les exécuter. Ceci permet de vérifier ce que ferait un Makefile sans l’appliquer réellement.
• -j [jobs] (ou --jobs[=jobs]) : autorise Make à exécuter simultanément un certain nombre de commandes (jobs). Si votre machine dispose d’un processeurs avec plusieurs cœurs, ceci permet de réduire considérablement le temps d’exécution du Makefile. Par exemple, avec un processeur à huit cœurs, vous pouvez utiliser l’option -j 8 pour que Make lance jusqu’à huit commandes en parallèle (une par cœur).

Dans un terminal, utilisez man make pour afficher le manuel et découvrir les options. Appuyez sur la touche q pour quitter le manuel.

2.6 Supprimer l’écho

Par défaut, Make affiche dans le terminal chaque ligne d’une recette exécutée. On appelle cela « l’écho », par analogie avec la commande echo qu’on utilise dans un terminal pour afficher des messages.

Il y a plusieurs manières de supprimer l’écho :

• On peut préfixer une ligne par une arobase @ pour supprimer l’écho pour cette ligne.

.PHONY: all

doc-fr.pdf : doc-fr.md
	@pandoc doc-fr.md -o doc-fr.pdf

doc-en.pdf : doc-en.md
	@pandoc doc-en.md -o doc-en.pdf

all : doc-fr.pdf doc-en.pdf

Remarque : il existe d’autres préfixes qu’on peut ajouter à une ligne pour modifier le comportement de Make. Par exemple, préfixer une ligne par - indique à Make qu’il ne doit pas s’interrompre en cas d’erreur, ce qui est pratique lorsqu’on dépanne un processus.

• On peut utiliser la cible spéciale .SILENT en indiquant des prérequis, ce qui supprimera l’écho pour la fabrication des prérequis correspondants.

.PHONY: all
.SILENT: doc-fr.pdf doc-en.pdf

doc-fr.pdf : doc-fr.md
	pandoc doc-fr.md -o doc-fr.pdf

doc-en.pdf : doc-en.md
	pandoc doc-en.md -o doc-en.pdf

all : doc-fr.pdf doc-en.pdf
# "make all" sera silencieux aussi !

Remarque : .PHONY et .SILENT sont deux exemples de cibles spéciales. Voir Special Targets dans le manuel GNU Make pour la liste complète.

• On peut utiliser l’option -s (ou --silent, --quiet) au moment d’exécuter la commande make. Toutes les recettes s’exécuteront alors silencieusement.

3.1 Expansion et opérateurs de définition

On parle d’expansion pour désigner le fait de remplacer une expression de la forme $(nom) par la valeur de la variable correspondante.

Ce concept devient important lorsqu’on définit des variables qui contiennent d’autres variables, et plus encore lorsque des variables sont redéfinies.

En effet, Make permet de gérer de manière très fine l’ordre dans lequel se passe l’expansion. Ceci repose sur l’utilisation de différents opérateurs de définition (voir la section How Make reads a Makefile du manuel de GNU Make pour la liste des opérateurs et leurs effets). Or les différences de comportement entre ces opérateurs sont souvent source de confusion.

Les deux opérateurs qu’on rencontre le plus fréquemment sont = et :=.

• Quand on utilise = pour définir une variable, l’expansion des variables contenues dans la valeur se fait au moment où la variable est utilisée. Ceci permet de changer la valeur en cours de route, si on redéfinit les variables utilisées dans la valeur.

mot = bonjour
hello = $(mot) à vous !
# la valeur de "hello" est "bonjour à vous !"

# on redéfinit "mot" en changeant sa valeur
mot = bonsoir
# la valeur de "hello" est maintenant "bonsoir à vous !"

• Quand on utilise := pour définir une variable, l’expansion des variables contenues dans la valeur se fait au moment où la variable est définie. Ceci permet de fixer la valeur une fois pour toutes. Exemple :

mot = bonjour
hello := $(mot) à vous !
# la valeur de "hello" est "bonjour à vous !"

# on redéfinit "mot"
mot = bonsoir
# la valeur de "hello" reste "bonjour à vous !"

# on redéfinit cette fois "hello", on répète la première définition
hello := $(mot) à vous !
# la valeur de "hello" est maintenant "bonsoir à vous !"

En résumé :

• Si on définit des variables qui contiennent des variables, et qu’on modifie ces définitions en cours de route, alors on peut alterner entre = et := suivant les besoins.
• En revanche, lorsqu’une variable contient une valeur simple (on parle aussi de valeur littérale), c’est-à-dire qu’elle ne contient pas elle-même de variable, alors utiliser = ou := ne fait aucune différence, puisqu’il n’y a rien dans la valeur de la variable définie qui nécessite une expansion.
• Et lorsque le Makefile ne contient que des variables définies une seule fois, alors utiliser = ou := ne fait aucune différence non plus, puisqu’il n’y a aucune redéfinition qui vient affecter l’expansion.

3.2 Variables spéciales

Make inclut quelques variables spéciales, dont le nom est réservé pour un comportement prédéfini.

Par exemple, lorsqu’on exécute make sans argument, c’est la première règle contenue dans le Makefile qui est appliquée. On peut utiliser la variable spéciale .DEFAULT_GOAL pour définir la règle à appliquer par défaut.

.PHONY: all
.DEFAULT_GOAL := doc.html

all : doc.pdf doc.html

doc.pdf : doc.md
	pandoc doc.md -o doc.pdf

doc.html : doc.md
	pandoc doc.md -o doc.html

Voir Special Variables dans le manuel GNU Make pour la liste complète.

6.1 Modèles (pattern rules)

Dans une règle implicite, au lieu d’indiquer explicitement le nom de cibles et de prérequis, on indique le modèle (en anglais pattern) que doivent suivre ces noms. Un modèle de nom contient le symbole pourcentage %, qui constitue la part variable du modèle, avec éventuellement un préfixe et/ou un suffixe, qui constituent la part fixe du modèle.

Exemples :

• %.txt désigne tous les fichiers dont le nom finit par .txt
• _% désigne tous les fichiers dont le nom commence par _
• _%.txt désigne tous les fichiers dont le nom commence par _ et finit par .txt

.PHONY: html

# liste des noms de fichiers Markdown présents
input = $(wildcard *.md)

# liste des noms de fichiers HTML à fabriquer
output = $(input:.md=.html)

# cible à fabriquer
html : $(output)

# règle implicite pour la fabrication
%.html : %.md
	recette …

6.2 Variables automatiques

Comme pour les variables spéciales, les variables automatiques sont des variables dont le nom est réservé. En revanche, leur valeur n’est pas définie manuellement mais calculée automatiquement (d’où leur nom) en fonction du contexte.

Les variables automatiques sont pensées pour être utilisées dans des règles implicites. Combiner les deux permet de réaliser facilement des traitements de fichiers par lots. À mes yeux, c’est l’une des fonctionnalités les plus utiles de Make.

.PHONY: html
input = $(wildcard *.md)
output = $(input:.md=.html)
html : $(output)
%.html : %.md
	pandoc $^ --output=$@

%.html : %.md styles.css
	pandoc $< --css=styles.css --output=$@

Voir Automatic variables dans le manuel GNU Make pour la liste complète des variables automatiques.