Comprendre les Makefiles et leur rôle dans l'automatisation des tâches de programmation

Les Makefiles sont des outils importants que les développeurs utilisent pour organiser et automatiser les processus logiciels tels que la compilation et la construction. Si vous avez affaire à de grands projets logiciels, les Makefiles constituent un moyen efficace de simplifier les tâches répétitives et d'améliorer la productivité. En écrivant des instructions spécifiques dans un Makefile, vous pouvez contrôler les étapes de construction du programme et vous assurer qu'elles sont exécutées avec précision et dans l'ordre souhaité. Dans cet article, nous passerons en revue le concept des Makefiles, leurs utilisations les plus importantes et comment commencer à créer vos propres Makefiles pour améliorer votre flux de travail de programmation.

Points clés

• Make utilise les fichiers Make, qui automatisent les processus de construction via les fichiers Make pour compiler le code efficacement.
• Créez des fichiers constitués de règles contenant des objectifs, des dépendances et des actions.
• Les fichiers Make nécessitent une indentation avec des tabulations, pas des espaces, alors faites attention aux espaces vides lorsque vous travaillez avec des fichiers Make.

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 fichiers Make et comment ils peuvent révolutionner votre processus de construction.

Qu'est-ce que les Makefiles ?

Les fichiers de fabrication et d'assemblage sont étroitement liés. Bien qu'il ne soit pas destiné uniquement à l'assemblage, Make est né des frustrations que l'assemblage peut provoquer.

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

La compilation est devenue populaire au début des années 1970 avec le développement du C, mais des langages plus récents tels que Typescript, Rust et Sass l'utilisent également. Une alternative est l'interprétation, qui utilise un middleware pour exécuter le code plutôt que de créer un fichier 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 contenant 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 l'assemblage.

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 créer chaque fichier de votre programme.

Les Makefiles sont construits autour du concept de « dépendance » (ou « prérequis ») qui effectue des vérifications à l'aide d'horodatages de fichiers. Cela signifie que Make peut considérablement accélérer le processus de compilation : au lieu de recompiler chaque fichier source, Make ne reconstruit que le strict minimum. Généralement, si le fichier source change, Make le recompile, sinon il le laisse tel quel.

À quoi ressemblent les Makefiles ?

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

Les Makefiles contiennent une série de règles qui décrivent comment créer chaque composant. Le modèle général de la règle ressemble à ceci :

target: dependencies
    actions

Voici, en gros, le makefile le plus simple, qui compile un seul fichier source en un fichier exécutable :

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

Avertissement
La deuxième ligne de ce Makefile est en retrait et l'espacement doit être d'une tabulation. Que vous copiez et collez un Makefile ou que vous l'écriviez à la main, veillez à conserver un seul caractère de tabulation au début des lignes irrégulières. Par exemple, si vous utilisez quatre espaces au lieu d'une tabulation, vous verrez une erreur du type « Makefile:2:*** séparateur manquant. Arrêt."

Dans cet exemple, la cible est le nom du fichier exécutable final : programme. La cible et le nom du fichier ne doivent pas nécessairement correspondre, mais c'est généralement le cas.

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

Écrivez le premier Makefile

Il n'y a rien de tel qu'une expérience pratique et, heureusement, Make est convivial 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 suit :

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

conseil
Si vous voyez une erreur du type « make : commande introuvable » lorsque vous essayez de l'exécuter, cela signifie que 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 vous-même en testant le fichier make 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 <stdio.h>

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

À ce stade, testez votre programme pour vous assurer qu'il est correct (et que gcc est installé) en exécutant la commande suivante :

gcc -o program program.c

Assurez-vous que gcc construit le programme avec succès, puis supprimez-le :

rm program

Écrire le Makefile de base

Créez maintenant l'exemple Makefile (nommé « 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 êtes sûr que Make a compilé et construit votre programme, testez son comportement en le réexécutant :

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 à créer des composants qui doivent être refactorisés. Essayez de mettre à jour le fichier source et vous remarquerez la différence :

touch program.c
make

ملاحظة
La commande tactile ici met uniquement à 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 faire d’autre Make ?

Make est vraiment limité par sa nature basée sur des fichiers. N'importe quel fichier peut faire partie de votre processus de construction et servir de cible ou de 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 fichier Make reconstruira une page Web donnée :

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

Ici, nous venons d'effleurer la surface de ce que Make peut faire. En fait, les fichiers make 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 programme, 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 avoir une idée de ce qui se passe sous le capot. Avec le manuel GNU là-bas fais-le à portée de main, Vous pouvez commencer à utiliser Make pour vos propres projets afin d'éviter les temps d'arrêt inutiles.