makefile Tutoriel
Démarrer avec makefile

Remarques

Versions

Makefile de base

Envisagez d'écrire un "bonjour le monde!" programme en c. Disons que notre code source est dans un fichier appelé source.c, maintenant pour exécuter notre programme, nous devons le compiler, généralement sous Linux (en utilisant gcc), nous aurions besoin de taper $> gcc source.c -o output où output est le nom de l'exécutable à générer. Pour un programme de base, cela fonctionne bien mais, à mesure que les programmes deviennent plus complexes, notre commande de compilation peut aussi devenir plus complexe. C'est là qu'un Makefile entre en jeu, les makefiles nous permettent d'écrire un ensemble assez complexe de règles sur la façon de compiler un programme et de le compiler simplement en tapant make sur la ligne de commande. Par exemple, voici un exemple possible Makefile pour l'exemple hello wold ci-dessus.

Makefile de base

Permet de créer un fichier Makefile de base et de l’enregistrer sur notre système dans le même répertoire que notre code source nommé Makefile . Notez que ce fichier doit être nommé Makefile, cependant le capitol M est facultatif. Cela dit, il est relativement standard d'utiliser un capitol M.

output: source.c
    gcc source.c -o output

Notez qu'il existe exactement un onglet avant la commande gcc sur la deuxième ligne (ceci est important dans les makefiles). Une fois que ce Makefile est écrit chaque fois que les types d'utilisateurs font (dans le même répertoire que le Makefile), make vérifiera si le fichier source.c a été modifié (vérifie l'horodatage) s'il a été modifié plus récemment la règle de compilation sur la ligne suivante.

Variables dans les Makefiles

Selon le projet, vous pouvez souhaiter introduire des variables dans votre fichier de création. Voici un exemple de Makefile avec des variables présentes.

CFLAGS = -g -Wall

output: source.c
    gcc $< $(CFLAGS) -o $@

Maintenant, explorons ce qui s'est passé ici. Dans la première ligne, nous avons déclaré une variable nommée CFLAGS qui contient plusieurs indicateurs communs que vous souhaiterez peut-être transmettre au compilateur. Notez que vous pouvez stocker autant de drapeaux que vous voulez dans cette variable. Ensuite, nous avons la même ligne que avant de dire à make de vérifier la source.c pour voir si elle a été modifiée plus récemment que la sortie, si oui, elle exécute la règle de compilation. Notre règle de compilation est la même que précédemment, mais elle a été raccourcie en utilisant des variables, la variable $< est intégrée à make (appelée variable automatique, voir https://www.gnu.org/software/make/manual/ html_node / Automatic-Variables.html ) et il représente toujours la source. Dans ce cas, source.c . $(CFLAGS) est notre variable que nous avons définie auparavant, mais notons que nous avons dû mettre la variable entre parenthèses avec un $ devant comme ceci $(someVariable) . C'est la syntaxe pour dire à Make d'étendre la variable à ce que vous avez tapé auparavant. Enfin , nous avons le symbole $ @ pour , une fois de plus est une variable construite en faire, et il signifie simplement la cible de l'étape de compilation, donc dans ce cas , il est synonyme de sortie.

Nettoyer

Make clean est un autre concept utile pour apprendre à créer des fichiers. Permet de modifier le Makefile d'en haut

CFLAGS = -g -Wall
TARGETS = output

output: source.c
    gcc $< $(CFLAGS) -o $@

clean:
    rm $(TARGETS)

Comme vous pouvez le constater, nous avons simplement ajouté une règle de plus à notre Makefile et une variable supplémentaire contenant toutes nos cibles. C'est une règle quelque peu courante dans makefiles car elle vous permet de supprimer rapidement tous les binaires produits en tapant simplement $> make clean . En tapant make clean, vous indiquez au programme make d'exécuter la règle clean, puis make exécutera la commande rm pour supprimer toutes vos cibles.

J'espère que ce bref aperçu de l'utilisation de make vous aidera à accélérer votre flux de travail, les Makefiles peuvent devenir très complexes, mais avec ces idées, vous devriez pouvoir commencer à utiliser make et mieux comprendre ce qui se passe dans d'autres Makefiles . Pour plus d'informations sur l'utilisation de make, une excellente ressource est https://www.gnu.org/software/make/manual/ .

Définir des règles

Démarrage rapide

Une règle décrit quand et comment certains fichiers ( cibles de la règle) sont créés. Il peut également servir à mettre à jour un fichier cible si l'un des fichiers requis pour sa création ( prérequis de la cible) est plus récent que la cible.

Les règles suivent la syntaxe ci-dessous: (Notez que les commandes suivant une règle sont en retrait par une tabulation )

targets: prerequisites
        <commands>

où les cibles et les prérequis sont des noms de fichiers ou des noms réservés spéciaux et des commandes (le cas échéant) sont exécutés par un shell pour créer / reconstruire des cibles obsolètes.

Pour exécuter une règle, il vous suffit d'exécuter la commande make dans le terminal à partir du même répertoire que le fichier Makefile . L'exécution de make sans spécifier la cible exécute la première règle définie dans le Makefile . Par convention, la première règle du Makefile est souvent appelée all ou default , listant généralement toutes les cibles de build valides comme conditions préalables.

make exécute uniquement la règle si la cible est obsolète, ce qui signifie qu'elle n'existe pas ou que son heure de modification est antérieure à l'une de ses conditions préalables. Si la liste des prérequis est vide, la règle ne sera exécutée que lorsqu'elle sera appelée pour la première fois pour générer les cibles. Cependant, lorsque la règle ne crée pas de fichier et que la cible est une variable factice, la règle sera toujours exécutée.

foo.o: foo.c
    cc -c $< -o $@

bar.o: bar.c
    cc -c $< -o $@

%.o: %.c
    cc -c $< -o $@

Règles implicites

Les règles implicites disent make comment utiliser les méthodes habituelles pour construire certains types de fichiers cibles, qui sont très souvent utilisés. make utilise le nom du fichier cible pour déterminer la règle implicite à appeler.

L'exemple de règle de modèle que nous avons vu dans la section précédente n'a pas besoin d'être déclaré dans un fichier Makef, car make a une règle implicite pour la compilation C. Ainsi, dans la règle suivante, les conditions préalables foo.o et bar.o seront bar.o en utilisant la règle implicite pour la compilation C, avant de construire foo .

foo : foo.o bar.o
    cc -o foo foo.o bar.o $(CFLAGS) $(LDFLAGS)

Un catalogue de règles implicites et les variables utilisées par celles-ci peuvent être trouvées ici .

règle générique pour gzip un fichier

si un répertoire contient 2 fichiers:

$ ls
makefile
example.txt

et makefile contiennent le texte suivant

%.gz: %
    gzip $<

alors vous pouvez obtenir example.txt.gz en tapant dans le shell

$ make -f makefile example.txt.gz

le makefile ne contiennent qu'une seule règle qui instruisent comment faire pour créer un fichier dont l' extrémité nom avec .gz s'il y a un fichier avec le même nom mais le suffixe .gz.

makefile Bonjour tout le monde

C: \ makefile:

helloWorld :
[TAB]echo hello world

exécuter les résultats:

C:\>make
echo hello world
hello world

Remarque: [TAB] doit être remplacé par un onglet réel, stackoverflow remplace les tabulations par des espaces et les espaces ne sont pas utilisés de la même manière que les tabulations d'un fichier Make.