Linux make Commande avec des exemples

Présentation

Le Linux make La commande est un utilitaire couramment utilisé par les administrateurs système et les développeurs. La commande assiste le processus de compilation et est un outil indispensable pour créer des applications volumineuses. Cet utilitaire élimine les répétitions et accélère la compilation, ce qui permet de gagner du temps.

Cet article vous montrera comment utiliser Linux make commande avec des exemples.

Prérequis

• Accès au terminal.
• Le make fonction installée.
• Un éditeur de texte.

Remarque : Si make n'est pas disponible sur le système, utilisez sudo apt install make .

Comment fonctionne la commande make ?

Le make La commande compile différents morceaux de programme et construit un exécutable final. Le but de make est d'automatiser la compilation des fichiers, ce qui rend le processus plus simple et moins chronophage.

La commande fonctionne avec n'importe quel langage de programmation tant que le compilateur peut être exécuté avec une commande shell.

La compilation est simple lorsque vous travaillez avec quelques fichiers. Par conséquent, le processus inclut l'appel du compilateur et la liste des noms de fichiers.

Par exemple, pour compiler un programme C à partir de trois fichiers (file1.c , fichier2.c , fichier3.h ):

Appelez le compilateur avec :

gcc file1.c file2.c file3.h

Le gcc la commande crée un a.out fichier, qui est un exécutable compilé standard.

Cependant, changer l'un des fichiers source nécessite de tout recompiler, ce qui est encore plus compliqué lorsque l'on travaille avec de grosses applications. Le make La commande automatise le processus, permettant aux utilisateurs de mettre à jour uniquement les éléments qui doivent être modifiés sans recompiler chaque fichier.

Le make La commande utilise un fichier généré par l'utilisateur, Makefile, pour compiler les éléments du programme. Lorsqu'il est exécuté pour la première fois, make recherche dans le Makefile des instructions, par exemple, des descriptions de fichiers et des heures de modification. Sur la base des données disponibles, make décide quels fichiers doivent être mis à jour et émet les commandes nécessaires.

Que sont les Makefiles ?

Un Makefile est un fichier texte contenant un ensemble de règles qui indiquent make comment construire une application. Une règle se compose de trois parties :la cible , dépendances , et commande(s) .

La syntaxe de base du Makefile est :

target: dependencies
<TAB> commands

Certaines parties de la syntaxe sont :

• Cibles . Noms des fichiers à créer ou à mettre à jour après l'exécution de make .
• Dépendances . Noms des fichiers (séparés par des espaces) à partir desquels la cible est construite.
• Les commandes . Règles décrivant comment créer ou mettre à jour la cible lorsque les dépendances changent.

Un Makefile a plusieurs ensembles de règles. La première règle est celle par défaut et indique comment l'exécutable final (la cible) doit être créé à partir de fichiers objets non encore créés (dépendances) :

La syntaxe dans ce cas est :

EXECUTABLE: Object file 1, Object file 2
<TAB> commands

Remarque : Les commandes dans Makefiles viennent toujours après la TAB clé. Sinon, la commande ne fonctionne pas.

Après avoir défini la première règle, l'utilisateur ajoute des instructions sur la façon de créer des fichiers objets :

Le make La commande fonctionne en compilant les fichiers source en fichiers objet, puis en compilant les fichiers objet dans le fichier cible, l'exécutable final. La syntaxe Makefile avec les trois règles mentionnées ci-dessus est :

EXECUTABLE: Object file 1, Object file 2
<TAB> commands

Object file 1: Source file 1, Source file 2
<TAB> commands

Object file 2: Source file 2
<TAB> commands

Linux make syntaxe de commande

Le make de base la syntaxe ressemble à ceci :

make [OPTIONS]

Lorsqu'il est exécuté sans arguments, make construit la première cible à partir du Makefile.

Options de commande Linux make

Le make La commande est largement utilisée en raison de son efficacité, de sa variété et de sa capacité à effectuer des actions spécifiques. Alors que la commande imprime le résultat lorsqu'elle est exécutée sans options, l'ajout d'arguments développe make s convivialité.

Voici les options les plus utilisées :

Commande	Description
-B , --always-make	Compile inconditionnellement toutes les cibles.
-d , --debug[=FLAGS]	Imprime les informations de débogage.
-C dir , --directory=dir	Change le répertoire avant d'exécuter le Makefile.
-f file , --file=file , --Makefile=FILE	Utilise un fichier spécifique comme Makefile.
-i , --ignore-errors	Ignore toutes les erreurs dans les commandes.
-I dir , --include-dir=dir	Spécifie un répertoire pour rechercher le Makefile spécifié.
-j [jobs] , --jobs[=jobs]	Spécifie le nombre de tâches à exécuter simultanément.
-k , --keep-going	Continue à exécuter make aussi longtemps que possible après avoir reçu une erreur.
-l [load] , --load-average[=load]	Spécifie qu'aucune nouvelle tâche ne doit être démarrée si d'autres tâches sont dans la file d'attente.
-n , --dry-run , --just-print , --recon	Imprime la sortie attendue sans exécuter make .
-o file , --old-file=file , --assume-old=file	Assure que make ne refait pas le fichier même s'il est plus ancien que les dépendances.
-p , --print-data-base	Imprime la base de données produite après lecture du Makefile.
-q , --question	Active le mode Question, dans lequel make n'exécute aucune commande mais renvoie un état de sortie zéro si la cible est déjà compilée.
-r , --no-builtin-rules	Élimine les règles implicites intégrées.
-s , --silent , --quiet	Interdit l'impression des commandes au fur et à mesure qu'elles sont exécutées.
-S , --no-keep-going , --stop	Arrête "-k , --keep-going " commande.
-t , --touch	Touche les fichiers au lieu d'exécuter les commandes.
--trace	Trace la disposition de chaque cible.
-W file , --what-if=file , --new-file=file , --assume-new=file	Ignore le fait que le fichier cible a été modifié.
--warn-undefined-variables	Avertit qu'une variable inconnue est référencée.

Exemples de commandes Linux make

La meilleure façon de comprendre make et Makefiles consiste à exécuter la commande et différentes options sur un programme simple.

Par exemple, pour créer un exécutable qui affiche le message "En savoir plus sur les Makefiles" , suivez ces étapes :

1. Créez un répertoire appelé Test .

2. Créez trois fichiers source main.c , texte.c , et text.h :

• main.c - est le fichier avec la fonction principale (int main ) qui appelle une fonction depuis un autre fichier.

• texte.c - est le fichier avec le que vous voulez imprimer "En savoir plus sur les Makefiles!".

• texte.h - est le fichier d'en-tête avec les déclarations des fonctions. L'en-tête est inclus à la fois dans c fichiers avec le #include argument, qui a le même but que copier/coller le contenu de l'en-tête.

Les sections suivantes illustrent certains cas d'utilisation courants de make et Makefiles sur les trois fichiers mentionnés ci-dessus.

Remarque : Les exemples suivants sont écrits en langage C.

Créer un programme

Il existe deux manières de créer un programme :

• Compiler les fichiers de manière standard en appelant le compilateur gcc. Cette méthode convient aux petits programmes.
• Utiliser make et Makefiles.

Créer un programme avec le compilateur gcc

Utilisez le compilateur gcc uniquement pour les programmes simples. Sinon, utilisez Makefiles lorsque vous travaillez avec un grand nombre de fichiers.

Pour créer un programme avec le compilateur :

1. Ouvrez le terminal et accédez au répertoire contenant les fichiers.

2. Appelez le gcc compilateur et tapez le nom des deux c des dossiers. L'en-tête n'est pas compilé car il est déjà inclus dans c fichiers.

gcc main.c text.c

3. Lister tous les fichiers du répertoire courant avec le ls commande :

ls

Le terminal montre que le nouvel exécutable a.out fichier est créé. L'exécutable est également visible via un explorateur de fichiers :

Pour tester si la compilation a réussi, invoquez l'exécutable avec :

./a.out

Le terminal montre que l'exécutable fonctionne correctement.

Créer un programme avec Make et Makefiles

Compiler des fichiers avec make et Makefiles est plus simple que d'utiliser le compilateur. Commencez par créer un nouveau document texte dans le même répertoire et nommez-le Makefile ou makefile .

Ouvrez le fichier et utilisez la syntaxe de base du Makefile comme guide :

1. Tapez le nom du nouvel exécutable comme cible, par exemple, my_app.

2. Ajouter des fichiers objets main.o et text.o que les dépendances. Le make La commande recompile la cible à chaque fois que les fichiers objets changent.

3. Appuyez sur TAB et invoquez le gcc compilateur pour les fichiers objets :

<TAB> gcc main.o text.o

4. Ajoutez le -o marquez et nommez la cible my_app.

Après avoir écrit la première règle, le Makefile ressemble à ceci :

my_app: main.o text.o
<TAB> gcc main.o text.o -o my_app

Ensuite, indiquez au Makefile comment créer main.o :

1. Définissez main.o comme cible.

2. Tapez main.c comme dépendance. main.c sert à créer et mettre à jour main.o .

3. Écrivez la commande suivante pour mettre à jour main.o à chaque fois main.c modifications :

gcc -c main.c

4. Ajoutez le -c flag pour indiquer au Makefile de ne pas créer un nouvel exécutable mais seulement de lire le code et de compiler le fichier objet.

main.o: main.c
<TAB> gcc -c main.c

Pour créer text.o , définissez ce fichier comme cible et ajoutez à la fois text.c et text.h comme dépendances. Cependant, le gcc la commande ne compile que le text.c fichier, car les en-têtes ne sont jamais compilés :

text.o: text.c text.h
<TAB> gcc -c text.c

Enregistrez le Makefile et tapez make dans le terminal.

Le make la commande a créé deux fichiers objet (main.o et text.o ) et l'exécutable (my_app ).

Pour vérifier que make a créé de nouveaux fichiers, exécutez ls encore :

Le terminal montre que l'exécution de la commande a créé my_app . Pour exécuter my_app fichier, tapez :

./my_app

Mettre à jour le programme

Lorsqu'un fichier source est modifié, make ne met à jour que les fichiers objets en fonction de ce fichier source. Par exemple, pour modifier le texte affiché lors de l'exécution de my_app de "En savoir plus sur les Makefiles " à "Où suis-je ?" :

1. Ouvrez text.c dans l'éditeur de texte :

2. Remplacez le texte par "Où suis-je ?" :

3. Enregistrez le fichier, ouvrez le terminal et exécutez make :

Le make la commande a détecté des changements dans text.c et recompilé uniquement ce fichier.

Pour vérifier la modification, lancez l'exécutable :

./my_app

Compiler tous les fichiers

Pour compiler tous les fichiers et pas seulement les fichiers modifiés, utilisez -B ou --always-make options.

Par exemple, pour modifier le texte dans le text.c fichier vers "En savoir plus sur les Makefiles" et enregistrez le fichier, entrez :

make -B

La sortie montre que make compilé tous les fichiers du dossier, même ceux qui n'ont pas été modifiés.

Nettoyer les fichiers d'objets

Lorsqu'un utilisateur exécute make pour la première fois, la commande crée des fichiers objets et l'exécutable. Par conséquent, pour désencombrer le dossier source et nettoyer les fichiers objets, ajoutez le clean fonction au Makefile :

clean:
<TAB> rm *.o my_app

La commande se compose de :

• La cible propre sans dépendances - la cible est toujours considérée comme obsolète et toujours exécutée.
• Le rm commande - supprime les objets spécifiés.
• Le *.o partie - correspond aux fichiers avec le o extension et nettoie les fichiers objets et my_app .

Pour nettoyer les fichiers objets, exécutez :

make clean

Après avoir exécuté ls encore une fois, le terminal montre que les fichiers objets et my_app ont été supprimés.

Exécuter make en mode débogage

Exécutez make en mode débogage pour afficher des informations supplémentaires sur le processus de compilation. Exécutez make avec le -d option pour afficher la sortie de débogage :

make -d

Utiliser un autre fichier comme Makefile

Par défaut, make recherche un fichier appelé Makefile ou makefile dans le répertoire courant. Pour utiliser un autre fichier, exécutez :

make -f [file_name]

Par exemple, si un Makefile est nommé my_file , exécutez :

make -f my_file

Utiliser des variables

Les variables dans les Makefiles représentent plusieurs noms de fichiers, arguments, cibles, dépendances, commandes, répertoires source ou autres éléments. De plus, une variable est définie par un nom et représente une chaîne de texte appelée la valeur de la variable.

Pour définir une variable, utilisez = . Par exemple, remplacez gcc avec une variable C.

C=gcc

my_app: main.o text.o
<TAB> $ (C) main.o text.o -o my_app

main.o:main.c
<TAB> $ (C) -c main.c
        
text.o: text.c text.h
<TAB> $ (C) -c text.c

Lors de l'exécution de make dans le terminal, la commande lit le C variable comme gcc :

Conclusion

Après avoir parcouru les exemples de ce tutoriel, vous savez comment utiliser le make commande sous Linux et son fonctionnement.

Ensuite, téléchargez la feuille de triche des commandes Linux pour apprendre d'autres commandes Linux importantes.