Recherche…


Remarques

Un makefile est un fichier texte qui contrôle le fonctionnement du programme make . Le programme make est généralement utilisé pour gérer la création de programmes à partir de leurs fichiers source, mais il peut généralement être utilisé pour gérer tout processus nécessitant la régénération de fichiers (ou de cibles ) après la modification d'autres fichiers (ou prérequis ). Le fichier makefile décrit la relation entre les cibles et les prérequis et spécifie également les commandes nécessaires pour mettre à jour la cible lorsqu'une ou plusieurs conditions préalables ont été modifiées. La seule façon que make détermine « de la date-ness » est en comparant le temps de modification des fichiers cibles et leurs conditions préalables.

Les Makefiles sont quelque peu uniques de plusieurs manières, ce qui peut être déroutant au départ.

Tout d'abord, un fichier makefile se compose de deux langages de programmation complètement différents dans le même fichier. La majeure partie du fichier est écrit dans une langue qui make peut comprendre: cette offre affectation de variables et de l' expansion, certaines capacités de préprocesseur (y compris d' autres fichiers, l' analyse conditionnelle des sections du fichier, etc.), ainsi que la définition des objectifs et de leur conditions préalables. De plus, chaque cible peut être associée à une recette qui spécifie quelles commandes doivent être invoquées pour que cette cible soit mise à jour. La recette est écrite sous forme de script shell (POSIX sh par défaut). Le programme make n'analyse pas ce script: il exécute un shell et transmet le script au shell à exécuter. Le fait que les recettes ne soient pas analysées par make , mais traitées par un processus shell distinct, est essentiel pour comprendre les makefiles.

Deuxièmement, un makefile n'est pas un langage procédural comme un script: comme make analyse le makefile, il construit un graphe orienté en interne où les cibles sont les nœuds du graphe et les relations préalables sont les arêtes. Ce n'est qu'après que tous les fichiers makefile ont été complètement analysés et que le graphe est terminé que make choisissez un nœud (cible) et que vous essayez de le mettre à jour. Afin de s’assurer qu’une cible est à jour, elle doit tout d’abord s’assurer que chacune des conditions préalables de cette cible est à jour, et ainsi de suite, de manière récursive.

Versions

prénom Aussi connu sous le nom Version initiale Version Date de sortie
POSIX faire 1992 IEEE Std 1003.1-2008, édition 2016 2016-09-30
NetBSD fait bmake 1988 20160926 2016-09-26
GNU make faire 1988 4.2.1 2016-06-10
SunPro fait faire 2006 2015-07-13
MSVS nmake 2003 2015p3 2016-06-27

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.

GNU make

Règles de motif

Les règles de modèle permettent de spécifier plusieurs cibles et de créer des noms de prérequis à partir de noms de cible. Ils sont plus généraux et plus puissants que les règles ordinaires, car chaque cible peut avoir ses propres conditions préalables. Dans les règles de modèle, une relation entre une cible et une condition préalable est générée sur la base de préfixes, y compris les noms de chemin d'accès et les suffixes, ou les deux.

Imaginons que nous voulions construire les cibles foo.o et bar.o , en compilant les scripts C, respectivement foo.c et bar.c Cela pourrait être fait en utilisant les règles ordinaires ci-dessous:

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

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

la variable automatique $< est le nom du premier prérequis et $@ le nom de la cible (une liste complète des variables automatiques peut être trouvée ici ).

Cependant, comme les cibles partagent le même suffixe, les deux règles ci-dessus peuvent désormais être remplacées par la règle de modèle suivante:

%.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.



Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow