Que sont-ils et que pouvez-vous en faire ?

Points clés à retenir

• Les Makefiles sont utilisés par Make, qui automatise les processus de construction via des makefiles pour compiler le code efficacement.

• Les Makefiles sont constitués de règles avec des cibles, des dépendances et des actions.

• Les Makefiles nécessitent une indentation à l'aide de tabulations et non d'espaces, alors faites attention à vos espaces lorsque vous travaillez avec des makefiles.

Si vous avez installé un logiciel à partir du code source, vous avez probablement utilisé Make. Mais qu’est-ce que ce programme et comment ça marche ? Apprenez tout sur les makefiles et comment ils peuvent révolutionner votre processus de construction.

Qu’est-ce que la compilation ?

Les Makefiles et la compilation sont inextricablement liés. Bien qu'ils ne soient pas uniquement destinés à la compilation, le programme Make est né des frustrations que la compilation peut provoquer.

La compilation prend les fichiers source et les convertit sous une autre forme. L'exemple classique est un fichier .c qui se compile en un fichier objet .o. Les programmes C subissent également un processus de liaison qui convertit les fichiers .o en un exécutable final. En fait, la construction d'un projet C comporte quatre étapes distinctes :

La compilation a été popularisée au début des années 1970 avec le développement du langage C, mais des langages plus récents comme Typescript, Rust et Sass l'utilisent également. L'alternative est l'interprétation, qui utilise un programme intermédiaire pour exécuter du code plutôt que de générer un exécutable autonome. Les langages interprétés incluent JavaScript, Python et Ruby.

Les programmes compilés s'exécutent généralement plus rapidement, parfois beaucoup plus rapidement, que les programmes interprétés. La compilation vérifie également votre code pour certains types d'erreurs que l'interprétation ne peut vérifier qu'au moment de l'exécution, il est donc plus facile de garantir que les programmes compilés sont corrects. Mais la compilation peut être un processus lent, en particulier pour les projets comportant des centaines ou des milliers de fichiers sources.

Que font les Makefiles ?

Les Makefiles sont utilisés par Make, un programme qui vous aide à automatiser votre processus de construction, y compris des tâches telles que la compilation.

Lorsque vous exécutez la commande make, elle recherche par défaut un fichier appelé Makefile ou makefile. Ce fichier doit contenir des instructions sur la façon de compiler (ou de construire) chaque fichier de votre programme.

Les Makefiles sont construits autour du concept de « dépendance » (ou de « prérequis ») qui effectue des vérifications à l'aide d'horodatages de fichiers. Cela signifie que Make peut accélérer considérablement la compilation : au lieu de recompiler chaque fichier source, Make ne reconstruit que le strict minimum. De manière générale, si un fichier source a changé, Make le recompile, sinon il le laisse tranquille.

À quoi ressemblent les Makefiles ?

La première chose que vous devez savoir sur les makefiles est que les espaces sont importants. Ceci est largement considéré comme une mauvaise décision de conception, mais nous y sommes coincés, alors soyez prudent !

Un makefile contient une série de règles qui décrivent comment construire chaque composant. Le modèle général d’une règle ressemble à ceci :

        target: dependencies
    actions
    

Voici, à peu près, le makefile le plus simple, qui compile un seul fichier source en un exécutable :

        program: program.c
    gcc -o program program.c
    

La deuxième ligne de ce makefile est en retrait et l'indentation doit être un seul caractère de tabulation. Que vous soyez en train de copier-coller ou de saisir manuellement un makefile, veillez à conserver un seul caractère de tabulation au début des lignes en retrait. Si, par exemple, vous utilisez quatre espaces au lieu d'une tabulation, vous verrez une erreur du type « Makefile:2 : *** séparateur manquant. Arrêtez ».

Dans cet exemple, la cible est le nom de l'exécutable final : programme. Il n’est pas nécessaire qu’une cible corresponde à un nom de fichier, mais c’est généralement le cas.

Il n'y a qu'une seule dépendance de cette cible – program.c – que Make utilisera pour décider quoi faire. Si le fichier « programme » est plus récent que « programme.c », Make ne fera rien.

Écrire votre premier Makefile

Il n'y a rien de tel qu'une expérience pratique et, heureusement, Make est assez facile à utiliser dans sa forme la plus simple.

Installer la marque

Sur une distribution Linux qui utilise apt, comme Ubuntu, Mint ou Debian, vous pouvez installer Make comme ceci :

        sudo apt install make
    

Sur macOS, vous pouvez installer Make via Xcode en exécutant cette commande :

        xcode-select --install
    

Alternativement, si homebrew est installé, exécutez :

        brew install make
    

Si vous voyez une erreur du type « make : commande introuvable » lorsque vous essayez de l'exécuter, le programme make n'est pas installé dans votre PATH. Vous pouvez résoudre ce problème en vérifiant qu'il est correctement installé.

Écrire un programme de test simple

Vous pouvez voir Make en action par vous-même en testant le makefile ci-dessus avec un simple programme C. Vous aurez juste besoin d'installer gcc et make pour essayer cela.

Créez un fichier nommé « program.c » et remplissez-le avec ce qui suit :

        #include 
int main()
{
    printf("Hello, world.n");
}
    

À ce stade, vérifiez que votre programme est correct (et que gcc est installé) en exécutant ce qui suit :

        gcc -o program program.c
    

Confirmez que gcc a réussi à construire le programme, puis supprimez-le :

        rm program
    

Écrire le Makefile de base

Créez maintenant l'exemple de makefile (sous la forme « Makefile » ou « makefile ») avec le contenu suivant :

        program: program.c
    gcc -o program program.c
    

Exécuter Make

Dans votre terminal, assurez-vous que votre répertoire de travail contient les fichiers Makefile et program.c, puis exécutez Make :

        make
    

Une fois que vous avez confirmé que Make a compilé et construit votre programme, testez son comportement en l'exécutant à nouveau :

        make
    

Make vous dit que tout est à jour, donc il ne fait rien pour le moment. C'est l'un des plus grands avantages de Make : il ne passera que du temps à construire les composants qui doivent être reconstruits. Essayez de mettre à jour votre fichier source et vous verrez la différence :

        touch program.c
make
    

La commande tactile ici met simplement à jour l'heure de modification du fichier à l'heure actuelle. Ceci est juste un moyen rapide de « tromper » Make en lui faisant croire que le fichier a changé.

Que peut-on faire d’autre ?

Make n'est vraiment limité que par sa nature basée sur des fichiers. N'importe quel fichier peut faire partie de votre processus de construction et agir comme une cible ou une dépendance.

Cela signifie que Make convient à un large éventail de projets. Tout ce qui comporte des étapes de construction prévisibles et reproductibles convient.

Par exemple, prenons un générateur de site statique qui génère des pages Web à partir d'autres sources, comprenant souvent des fichiers texte Markdown. Ce makefile reconstruira une page Web spécifique :

        index.html: index.md
    pandoc index.md index.html
    

Nous n'avons qu'effleuré la surface de ce que Make peut faire ici. En réalité, les makefiles contiennent des modèles permettant de définir des règles pour de nombreux fichiers différents, créant ainsi des chaînes de dépendances complexes.

La prochaine fois que vous créerez un logiciel, vérifiez s'il existe un fichier Make et essayez d'explorer son contenu. J'espère que vous pourrez comprendre certaines des bases et reconnaître une partie de ce qui se passe sous le capot. Avec le manuel GNU make en main, vous pouvez commencer à utiliser Make pour vos propres projets afin d'éviter les temps d'arrêt inutiles.