Un makefile qui décrit comment recompiler un programme peut s'utiliser de bien des façons. L'usage le plus simple consiste à recompiler tous les fichiers périmés (qui ont besoin d'être mis à jour). La plupart des makefiles sont écrits de sorte que si l'on exécute make sans aucun argument, c'est exactement ce comportement qui se produit.
Mais il se peut que vous vouliez ne mettre à jour que certains fichiers, ou utiliser un autre compilateur ou d'autres options de compilation, ou encore que vous vouliez simplement savoir quels fichiers sont périmés, sans les modifier.
En passant des arguments lorsque vous exécutez make, vous pouvez réaliser tout cela, ainsi que bien d'autres choses.
Le code de retour de make est toujours l'une des trois valeurs suivantes :
0Si make réussit, le code de retour est zéro.
2Si make rencontre une quelconque erreur, le code de retour est deux. Dans ce cas, des messages décrivant les erreurs particulières sont affichés.
1Si vous utilisez le drapeau ‘-q’ et que make détermine qu'une cible n'est pas déjà à jour, le code de retour est un. Voir Au lieu d'exécuter les recettes.
Pour indiquer le nom du makefile à utiliser, on emploie l'option ‘-f’ ou ‘--file’ (‘--makefile’ fonctionne également). Par exemple, ‘-f altmake’ indique d'utiliser le fichier altmake comme makefile.
Si vous utilisez le drapeau ‘-f’ plusieurs fois, en faisant suivre chaque ‘-f’ d'un argument, tous les fichiers indiqués sont utilisés conjointement comme makefiles.
Si vous n'utilisez pas le drapeau ‘-f’ ou ‘--file’, le comportement par défaut consiste à essayer GNUmakefile, makefile et Makefile, dans cet ordre, et à utiliser le premier de ces trois qui existe ou qui peut être créé (voir Écrire des makefiles).
Les buts sont les cibles que make doit s'efforcer de mettre à jour en dernier ressort. D'autres cibles sont elles aussi mises à jour si elles apparaissent comme prérequis (prerequisite) des buts, ou comme prérequis de prérequis des buts, et ainsi de suite.
Par défaut, le but est la première cible du makefile (sans compter les cibles qui commencent par un point). C'est pourquoi les makefiles sont habituellement écrits de sorte que la première cible serve à compiler l'ensemble du programme, ou des programmes, qu'ils décrivent. Si la première règle du makefile possède plusieurs cibles, seule la première cible de la règle devient le but par défaut, et non la liste entière. Vous pouvez gérer la sélection du but par défaut depuis l'intérieur de votre makefile au moyen de la variable .DEFAULT_GOAL (voir Autres variables spéciales).
Vous pouvez aussi spécifier un autre but, ou plusieurs buts, à l'aide des arguments de la ligne de commande de make. Donnez le nom du but comme argument. Si vous spécifiez plusieurs buts, make les traite l'un après l'autre, dans l'ordre où vous les nommez.
Toute cible du makefile peut être spécifiée comme but (sauf si elle commence par ‘-’ ou contient un ‘=’, auquel cas elle serait interprétée respectivement comme une option ou comme une définition de variable). Et même des cibles qui ne figurent pas dans le makefile peuvent être spécifiées, si make peut trouver des règles implicites indiquant comment les construire.
make place la liste des buts indiqués sur la ligne de commande dans la variable spéciale MAKECMDGOALS. Si aucun but n'a été donné sur la ligne de commande, cette variable est vide. Notez que cette variable ne devrait être utilisée que dans des situations particulières.
Un exemple d'usage approprié est d'éviter d'inclure les fichiers .d pendant l'exécution de la règle clean (voir Générer automatiquement les prérequis). Cela évite à make le gaspillage qui consisterait à supprimer aussitôt les fichiers .d qu'il vient de générer :
sources = foo.c bar.c ifeq (,$(filter clean,$(MAKECMDGOALS)) include $(sources:.c=.d) endif
L'un des usages de la spécification de buts est de ne compiler qu'une partie du programme, ou un seul programme parmi plusieurs. Indiquez comme but chacun des fichiers que vous voulez reconstruire. Par exemple, supposons que, dans un répertoire contenant plusieurs programmes, le makefile commence ainsi :
.PHONY: all all: size nm ld ar as
Si vous travaillez sur le programme nommé size, vous pouvez taper ‘make size’ pour ne recompiler que les fichiers qui concernent ce programme.
Un autre usage de la spécification de buts est de construire des fichiers qui ne le sont pas d'ordinaire. Par exemple, il peut exister un fichier de sortie de débogage, ou une version du programme compilée spécialement pour les tests, qui possède une règle dans le makefile mais n'est pas un prérequis du but par défaut.
Un usage encore différent de la spécification de buts est d'exécuter les recettes associées à des cibles factices (phony) (voir Cibles factices (Phony)) ou à des cibles vides (voir Fichiers cibles vides pour enregistrer des événements). De nombreux makefiles comportent une cible factice nommée clean qui supprime tout sauf les fichiers source. Naturellement, elle n'est exécutée que lorsqu'on la demande explicitement par ‘make clean’. Voici une liste de noms de cibles factices et de cibles vides fréquemment utilisés. Pour une liste détaillée des noms de cibles standard employés par les paquets logiciels GNU, voir Cibles standard à l'intention des utilisateurs.
Construit toutes les cibles de plus haut niveau que connaît le makefile.
Supprime tous les fichiers normalement créés par l'exécution de make.
Ressemble à ‘clean’, mais peut s'abstenir de supprimer certains fichiers que l'on ne souhaite généralement pas recompiler. Par exemple, la cible ‘mostlyclean’ de GCC ne supprime pas libgcc.a, car il est rarement nécessaire de le recompiler et cela prend beaucoup de temps.
Chacune de ces cibles peut être définie de manière à supprimer plus de fichiers que ‘clean’. Par exemple, elle supprimerait les fichiers de configuration ou les liens que vous créez d'ordinaire en préparation de la compilation, même si le makefile lui-même est incapable de créer ces fichiers.
Copie le fichier exécutable dans un répertoire que les utilisateurs parcourent habituellement pour trouver des commandes. Copie également les éventuels fichiers auxiliaires utilisés par l'exécutable dans les répertoires où il ira les chercher.
Imprime la liste des fichiers source modifiés.
Crée un fichier tar des fichiers source.
Crée une archive shell (fichier shar) des fichiers source.
Crée un fichier de distribution des fichiers source. Il peut s'agir d'un fichier tar, d'un fichier shar, d'une version compressée de l'un d'eux, voire d'une combinaison de plusieurs des formes ci-dessus.
Met à jour la table de balises (tags) de ce programme.
Exécute des autotests sur le programme que ce makefile construit.
Le makefile indique à make comment déterminer si une cible est à jour, et comment mettre à jour chaque cible. Mais mettre à jour les cibles n'est pas toujours le comportement souhaité. Certaines options servent à faire effectuer à make un travail autre que la mise à jour.
« Ne rien faire (No-op) ». Fait afficher par make les recettes (recipes) nécessaires pour mettre les cibles à jour, mais sans les exécuter réellement. Notez toutefois que certaines recettes sont exécutées malgré ce drapeau (voir Fonctionnement de la variable MAKE). Les recettes nécessaires à la mise à jour des makefiles inclus sont elles aussi exécutées (voir Comment les makefiles sont refaits).
« Toucher (Touch) ». Marque les cibles comme étant à jour sans réellement les modifier. Autrement dit, make fait seulement semblant de mettre à jour les cibles, sans en changer le contenu : il ne fait que réécrire leur date de modification.
« Question (Question) ». Vérifie si les cibles sont à jour sans rien afficher, mais sans exécuter de recettes. La nécessité ou non d'une mise à jour est indiquée par le code de retour.
« Et si (What if) ». Chacun des drapeaux ‘-W’ est suivi d'un nom de fichier. Sans toucher à la date de modification réelle des fichiers indiqués, make enregistre leur date de modification comme étant l'heure actuelle. En combinant le drapeau ‘-W’ avec le drapeau ‘-n’, vous pouvez voir ce qui se passerait si vous modifiiez certains fichiers.
Avec le drapeau ‘-n’, make affiche les recettes qu'il exécuterait normalement, mais la plupart du temps il ne les exécute pas.
Avec le drapeau ‘-t’, make ignore les recettes des règles et utilise (en fait) la commande touch sur chacune des cibles qui ont besoin d'être reconstruites. À moins que ‘-s’ ou .SILENT ne soit employé, cette commande touch est également affichée. Pour des raisons de rapidité, make ne lance pas réellement le programme touch : il effectue ce travail directement.
Avec le drapeau ‘-q’, make n'affiche rien et n'exécute aucune recette, mais renvoie un code de retour égal à zéro uniquement si les cibles concernées sont déjà à jour. Un code de retour égal à un signifie qu'une mise à jour est nécessaire. Si make rencontre une erreur, le code de retour est deux, ce qui permet de distinguer les erreurs des « cibles non à jour ».
Utiliser deux ou plus de ces trois drapeaux dans un même appel de make constitue une erreur.
Les options ‘-n’, ‘-t’ et ‘-q’ n'affectent pas les lignes de recette qui commencent par le caractère ‘+’, ni celles qui contiennent les chaînes ‘$(MAKE)’ ou ‘${MAKE}’. Notez que seules les lignes contenant le caractère ‘+’, ou les chaînes ‘$(MAKE)’ ou ‘${MAKE}’, sont exécutées indépendamment de ces options. Les autres lignes de la même règle ne sont pas exécutées, à moins qu'elles-mêmes ne commencent par ‘+’ ou ne contiennent ‘$(MAKE)’ ou ‘${MAKE}’ (voir Fonctionnement de la variable MAKE).
Le drapeau ‘-t’ empêche la mise à jour des cibles factices (phony) (voir Cibles factices (Phony)), sauf s'il existe des lignes de recette commençant par ‘+’, ou contenant ‘$(MAKE)’ ou ‘${MAKE}’.
Le drapeau ‘-W’ offre deux fonctions :
make ferait si vous modifiiez un certain fichier.
make exécute réellement les recettes, le drapeau ‘-W’ permet de faire se comporter make comme si certains fichiers avaient été modifiés, sans que les recettes correspondant à ces fichiers soient réellement exécutées.
Notez que vous pouvez obtenir d'autres informations sur make lui-même ou sur les makefiles utilisés grâce aux options ‘-p’ ou ‘-v’ (voir Résumé des options).
Il peut arriver que vous ayez modifié un fichier source sans vouloir pour autant recompiler tous les fichiers qui en dépendent. Par exemple, supposons que vous ajoutiez une macro ou une déclaration à un fichier d'en-tête dont de nombreux fichiers dépendent. Par prudence, make suppose que le moindre changement dans le fichier d'en-tête impose de recompiler tous les fichiers qui en dépendent. Or vous savez qu'ils n'ont pas besoin d'être recompilés, et vous préféreriez ne pas perdre de temps à attendre la fin de la compilation.
Si vous prévoyez ce problème avant de modifier le fichier d'en-tête, vous pouvez utiliser le drapeau ‘-t’. Ce drapeau indique à make de ne pas exécuter les recettes des règles, et de marquer à la place les cibles comme étant à jour en réécrivant leur date de dernière modification. Procédez comme suit :
make, les modifications du fichier d'en-tête ne provoqueront aucune recompilation.
Si vous avez déjà modifié le fichier d'en-tête à un moment où certains fichiers ont réellement besoin d'être recompilés, il est trop tard pour procéder ainsi. Vous pouvez alors employer à la place le drapeau ‘-o file’, qui marque le fichier indiqué comme « ancien (old) » (voir Résumé des options). Ainsi, ce fichier lui-même n'est pas reconstruit, et le fait qu'il ait changé ne provoque pas non plus la reconstruction d'autres fichiers. Procédez comme suit :
Un argument contenant un ‘=’ spécifie la valeur d'une variable : ‘v=x’ affecte la valeur x à la variable v. Lorsque vous spécifiez une valeur de cette façon, toutes les affectations ordinaires de la même variable dans le makefile sont ignorées. On dit alors que la variable a été redéfinie (override) par un argument de la ligne de commande.
L'usage le plus courant de cette fonctionnalité est de transmettre des drapeaux supplémentaires au compilateur. Par exemple, dans un makefile correctement écrit, la variable CFLAGS est incluse dans chaque recette qui lance le compilateur C, de sorte qu'un fichier foo.c serait compilé ainsi :
cc -c $(CFLAGS) foo.c
Ainsi, quelle que soit la valeur que vous donnez à CFLAGS, elle affecte chacune des compilations effectuées. Le makefile précise probablement la valeur usuelle de CFLAGS de la manière suivante :
CFLAGS=-g
Chaque fois que vous exécutez make, vous pouvez, si vous le souhaitez, redéfinir cette valeur. Par exemple, en tapant ‘make CFLAGS='-g -O'’, chaque compilation C sera effectuée avec ‘cc -c -g -O’. (Cela illustre aussi la manière d'employer les guillemets du shell pour traiter les espaces et autres caractères spéciaux contenus dans la valeur d'une variable lorsqu'on la redéfinit.)
La variable CFLAGS n'est que l'une des nombreuses variables standard prévues précisément pour être modifiées de cette façon. Pour une liste complète, voir Variables utilisées par les règles implicites.
Vous pouvez aussi programmer le makefile pour qu'il consulte des variables supplémentaires de votre cru. Ainsi, les utilisateurs peuvent contrôler d'autres aspects du comportement du makefile en modifiant ces variables.
Lorsque vous redéfinissez une variable par un argument de la ligne de commande, vous pouvez la définir aussi bien comme variable à expansion récursive que comme variable à expansion simple. Les exemples ci-dessus créent une variable à expansion récursive. Pour créer une variable à expansion simple, écrivez ‘:=’ ou ‘::=’ à la place de ‘=’. Cela dit, à moins que vous ne vouliez inclure une référence de variable ou un appel de fonction dans la valeur que vous spécifiez, peu importe le type de variable que vous créez.
Il existe une seule façon pour un makefile de modifier une variable que vous avez redéfinie : c'est d'utiliser la directive override, qui est une ligne de la forme ‘override variable = value’ (voir La directive override).
Normalement, lorsqu'une erreur survient pendant l'exécution d'une commande du shell, make abandonne immédiatement et renvoie un état non nul. Aucune recette n'est ensuite exécutée pour quelque cible que ce soit. L'erreur signifie que le but ne peut pas être correctement reconstruit, et make le signale dès qu'il s'en aperçoit.
Mais lorsque vous compilez un programme que vous venez de modifier, ce n'est pas le comportement souhaité. Vous préféreriez plutôt que make compile tous les fichiers qu'il peut, afin de vous montrer le plus d'erreurs de compilation possible.
Dans ce cas, vous devriez utiliser le drapeau ‘-k’ ou ‘--keep-going’. Il indique à make de continuer à examiner les autres prérequis de la cible en cours de traitement, et de les reconstruire si nécessaire, avant d'abandonner et de renvoyer un état non nul. Par exemple, après qu'une erreur s'est produite lors de la compilation d'un fichier objet, ‘make -k’ poursuit la compilation des autres fichiers objet, même s'il sait déjà qu'il sera impossible de les lier. En plus de poursuivre après une commande du shell ayant échoué, ‘make -k’ continue autant que possible après avoir constaté qu'il ne sait pas comment construire une cible ou un fichier prérequis. Cela provoque toujours un message d'erreur, mais sans ‘-k’ ce serait une erreur fatale (voir Résumé des options).
Le comportement habituel de make suppose que votre objectif est de mettre le but à jour. C'est pourquoi, dès que make constate que c'est impossible, mieux vaut qu'il signale aussitôt l'échec. Le drapeau ‘-k’ indique que votre véritable objectif est de tester autant que possible les modifications apportées au programme, en trouvant peut-être plusieurs problèmes indépendants les uns des autres, afin de les corriger tous ensemble avant de tenter la compilation suivante. C'est la raison pour laquelle la commande M-x compile d'Emacs passe par défaut le drapeau ‘-k’.
Dans certaines situations, make a besoin de créer ses propres fichiers temporaires. Ces fichiers ne doivent pas être perturbés pendant l'exécution de make (y compris toutes les instances de make appelées récursivement).
Si la variable d'environnement MAKE_TMPDIR est définie, tous les fichiers temporaires créés par make y sont placés.
Si MAKE_TMPDIR n'est pas définie, c'est l'emplacement standard des fichiers temporaires du système d'exploitation courant qui est utilisé. Sur les systèmes POSIX, il s'agit de l'emplacement défini par la variable d'environnement TMPDIR, ou bien de l'emplacement par défaut du système (par exemple /tmp). Sous Windows, on consulte d'abord TMP, puis TEMP, puis TMPDIR, et enfin l'emplacement par défaut des fichiers temporaires du système.
Notez que ce répertoire doit déjà exister, sinon make échoue. make ne tente pas de créer ce répertoire.
Ces variables ne peuvent pas être définies depuis l'intérieur d'un makefile, car GNU make a besoin d'accéder à cet emplacement avant de commencer à lire le makefile.
Voici une liste de toutes les options que make comprend :
Ces options sont ignorées, par compatibilité avec d'autres versions de make.
Considère toutes les cibles comme périmées (ayant besoin d'une mise à jour). GNU make examine les cibles et leurs prérequis selon l'algorithme habituel, mais toute cible ainsi examinée est toujours reconstruite, quel que soit l'état de ses prérequis. Pour éviter une récursion infinie, si MAKE_RESTARTS (voir Autres variables spéciales) est défini à une valeur supérieure à 0, cette option est désactivée lorsqu'on examine s'il faut reconstruire les makefiles (voir Comment les makefiles sont refaits).
Se déplace dans le répertoire dir avant de lire les makefiles. Si plusieurs options ‘-C’ sont indiquées, chacune est interprétée relativement à la précédente : ‘-C / -C etc’ équivaut à ‘-C /etc’. Cette option est généralement utilisée avec les appels récursifs de make (voir Utilisation récursive de make).
Affiche des informations de débogage en plus du traitement normal. Les informations de débogage vous renseignent sur tout ce qui est intéressant à propos de la façon dont make décide quoi faire : quels fichiers sont envisagés pour être reconstruits, quelles dates de fichiers sont comparées et avec quel résultat, quels fichiers ont réellement besoin d'être reconstruits, quelles règles implicites sont envisagées et lesquelles sont appliquées, etc. L'option -d équivaut à ‘--debug=a’ (voir ci-dessous).
Affiche des informations de débogage en plus du traitement normal. Le niveau et le type de sortie peuvent être choisis de diverses façons. En l'absence d'argument, le niveau de débogage « basique (basic) » est affiché. Les arguments possibles sont indiqués ci-dessous. Seul le premier caractère est pris en compte, et les valeurs doivent être séparées par des virgules ou des espaces.
a (all)Active tous les types de sortie de débogage. Cela équivaut à utiliser ‘-d’.
b (basic)Débogage basique. Affiche chaque cible jugée périmée, et indique si la construction a réussi ou non.
v (verbose)Un niveau au-dessus de ‘basic’. Inclut des messages indiquant quels makefiles ont été analysés, quels prérequis n'avaient pas besoin d'être reconstruits, etc. Cette option active aussi les messages ‘basic’.
i (implicit)Affiche des messages décrivant la recherche de règles implicites pour chaque cible. Cette option active aussi les messages ‘basic’.
j (jobs)Affiche des messages détaillant l'invocation de chaque sous-commande.
m (makefile)Par défaut, les messages ci-dessus ne sont pas activés pendant que make tente de reconstruire les makefiles. Cette option active les messages également pendant la reconstruction des makefiles. Notez que l'option ‘all’ active aussi cette option. Cette option active aussi les messages ‘basic’.
p (print)Affiche les recettes exécutées, même celles qui ne le seraient normalement pas (à cause de .SILENT ou de ‘@’). Affiche également le nom du makefile et le numéro de ligne où la recette est définie.
w (why)Explique pourquoi chaque cible doit être reconstruite, en indiquant quels prérequis sont plus récents que la cible.
n (none)Désactive tout débogage actuellement activé. Si des drapeaux de débogage supplémentaires apparaissent par la suite, ils restent activés.
Donne la priorité aux variables issues de l'environnement sur les variables du makefile. Voir Variables issues de l'environnement.
Évalue string comme de la syntaxe de makefile. C'est l'équivalent en ligne de commande de la fonction eval (voir La fonction eval). L'évaluation a lieu après la définition des règles et variables par défaut, mais avant la lecture des makefiles.
Lit le fichier nommé file comme makefile. Voir Écrire des makefiles.
Rappelle les options que make comprend, puis quitte.
Ignore toutes les erreurs dans les recettes exécutées pour reconstruire des fichiers. Voir Erreurs dans les recettes.
Indique un répertoire dir où chercher les makefiles inclus. Voir Inclure d'autres makefiles. Si plusieurs options ‘-I’ sont utilisées pour indiquer plusieurs répertoires, ces derniers sont parcourus dans l'ordre indiqué. Si le répertoire dir est un simple tiret (-), tous les répertoires déjà indiqués jusque-là (y compris le chemin de répertoires par défaut) sont écartés. La liste courante des répertoires à parcourir peut être consultée dans la variable .INCLUDE_DIRS.
Indique le nombre de recettes (tâches, jobs) à exécuter simultanément. En l'absence d'argument, make exécute autant de recettes que possible en même temps. S'il y a plusieurs options ‘-j’, c'est la dernière qui est prise en compte. Pour plus de détails sur la façon dont les recettes sont exécutées, voir Exécution parallèle. Notez que cette option est ignorée sous MS-DOS.
Choisit le style de jobserver à utiliser. Cette option n'a d'effet que si les constructions parallèles sont activées (voir Exécution parallèle). Sur les systèmes POSIX, style peut valoir fifo (la valeur par défaut) ou pipe. Sous Windows, le seul style accepté est sem (la valeur par défaut). Cette option est utile si vous devez utiliser une ancienne version de GNU make, ou un autre outil qui nécessite un style de jobserver particulier.
Poursuit le travail autant que possible après une erreur. Bien que la cible ayant échoué, et celles qui en dépendent, ne puissent pas être reconstruites, les autres prérequis de ces cibles peuvent malgré tout être traités. Voir Tester la compilation d'un programme.
Indique de ne pas démarrer de nouvelle recette s'il y a d'autres recettes en cours d'exécution et que la moyenne de charge (load average) atteint au moins load (un nombre à virgule flottante). En l'absence d'argument, supprime une limite de charge antérieure. Voir Exécution parallèle.
Sur les systèmes qui prennent en charge les liens symboliques, cette option indique à make de prendre en compte l'horodatage du lien symbolique lui-même, en plus de celui du fichier auquel le lien fait référence. Lorsque cette option est indiquée, c'est l'horodatage le plus récent parmi le fichier et le lien symbolique qui est retenu comme date de modification de la cible.
Affiche les recettes qui seraient exécutées, mais ne les exécute pas (sauf dans certaines situations). Voir Au lieu d'exécuter les recettes.
Ne reconstruit pas le fichier file même s'il est plus ancien que ses prérequis, et ne reconstruit rien d'autre sous prétexte d'un changement de file. Pour l'essentiel, le fichier est traité comme s'il était extrêmement ancien et sa règle est ignorée. Voir Éviter la recompilation de certains fichiers.
Fait en sorte que la sortie de chaque recette soit affichée d'un seul tenant, sans interruption. Cette option n'est utile que lorsque vous utilisez l'option --jobs pour exécuter plusieurs recettes simultanément (voir Exécution parallèle). Sans cette option, la sortie est affichée au fur et à mesure que les recettes la produisent.
Si type n'est pas indiqué, ou s'il vaut ‘target’, la sortie de l'ensemble de la recette de chaque cible est regroupée. Si type vaut ‘line’, la sortie de chaque ligne de la recette est regroupée. Si type vaut ‘recurse’, la sortie de l'ensemble d'un make récursif est regroupée. Si type vaut ‘none’, aucune synchronisation de la sortie n'est effectuée. Voir Sortie pendant l'exécution parallèle.
Affiche la base de données (règles et valeurs des variables) résultant de la lecture des makefiles, puis exécute comme d'habitude ou comme indiqué par ailleurs. Cela affiche aussi les informations de version indiquées par le commutateur ‘-v’ (voir ci-dessous). Pour afficher la base de données sans tenter de reconstruire de fichiers, utilisez ‘make -qp’. Pour afficher la base de données des règles et variables prédéfinies, utilisez ‘make -p -f /dev/null’. La sortie de la base de données contient le nom du fichier et le numéro de ligne pour les définitions de recettes et de variables, ce qui en fait un outil de débogage utile dans les environnements complexes.
« Mode question (Question mode) ». N'exécute aucune recette et n'affiche rien. Il se contente de renvoyer un code de retour : zéro si les cibles indiquées sont déjà à jour, un si une reconstruction est nécessaire, et deux s'il rencontre une erreur. Voir Au lieu d'exécuter les recettes.
Renonce à l'utilisation des règles implicites intégrées (voir Utilisation des règles implicites). Vous pouvez toujours définir vos propres règles en écrivant des règles de motif (voir Définition et redéfinition des règles de motif). L'option ‘-r’ efface aussi la liste des suffixes par défaut pour les règles de suffixe (voir Les anciennes règles de suffixe). Mais vous pouvez toujours définir vos propres suffixes avec une règle pour .SUFFIXES, puis définir vos propres règles de suffixe. Notez que seules les règles sont affectées par l'option -r ; les variables par défaut restent en vigueur (voir Variables utilisées par les règles implicites). Voir aussi l'option ‘-R’ ci-dessous.
Renonce à l'utilisation des variables intégrées propres aux règles (voir Variables utilisées par les règles implicites). Vous pouvez bien sûr toujours définir vos propres variables. L'option ‘-R’ active aussi automatiquement l'option ‘-r’ (voir ci-dessus), car il n'y a aucun sens à avoir des règles implicites sans aucune définition des variables qu'elles utilisent.
Fonctionne silencieusement. N'affiche pas les recettes au moment où elles sont exécutées. Voir L'écho des recettes.
Annule l'effet de l'option ‘-k’. Cela n'est jamais nécessaire, sauf dans un make récursif où ‘-k’ est hérité du make de plus haut niveau par l'intermédiaire de MAKEFLAGS (voir Utilisation récursive de make), ou lorsque vous avez défini ‘-k’ dans la variable d'environnement MAKEFLAGS.
Cette option active une forme de test par fuzzing des relations entre prérequis. Lorsque l'exécution parallèle est activée (‘-j’), l'ordre dans lequel les cibles sont construites devient moins déterministe. Si les prérequis ne sont pas entièrement déclarés dans le makefile, cela peut conduire à des échecs de construction intermittents et difficiles à diagnostiquer.
L'option ‘--shuffle’ demande à make de réorganiser délibérément les buts et les prérequis. Les relations entre cibles et prérequis sont préservées, mais l'ordre des prérequis d'une cible donnée est réordonné comme expliqué ci-dessous.
L'ordre dans lequel les prérequis apparaissent dans les variables automatiques n'est pas modifié par cette option.
La pseudo-cible .NOTPARALLEL désactive le mélange (shuffle) pour ce makefile. De même, les listes de prérequis contenant .WAIT ne sont pas mélangées. Voir Désactiver l'exécution parallèle.
L'option ‘--shuffle=’ accepte les valeurs suivantes :
randomChoisit une graine (seed) aléatoire pour le mélange. C'est la valeur par défaut si aucun mode n'est indiqué. La graine choisie est aussi transmise aux commandes sous-make. La graine figurant également dans les messages d'erreur, vous pouvez la réutiliser lors d'exécutions ultérieures pour reproduire le problème, ou vérifier qu'il a disparu.
reversePlutôt qu'un mélange aléatoire, inverse l'ordre des buts et des prérequis.
seedUtilise un mélange ‘random’ initialisé avec la valeur de graine indiquée. seed est un entier.
noneDésactive le mélange. Cela annule toute option ‘--shuffle’ antérieure.
Au lieu d'exécuter les recettes, touche les fichiers (les marque comme étant à jour sans réellement les modifier). Cela sert à faire croire qu'une recette a été exécutée, afin de tromper de futurs appels de make. Voir Au lieu d'exécuter les recettes.
Affiche des informations de trace de l'exécution de make. Utiliser --trace est un raccourci pour --debug=print,why.
Affiche la version du programme make, ainsi que la notice de copyright, la liste des auteurs et un avis indiquant l'absence de garantie, puis quitte.
Affiche un message contenant le répertoire de travail, à la fois avant et après l'exécution du makefile. Cela peut être utile pour repérer l'origine des erreurs lorsque des commandes make récursives sont imbriquées de façon complexe. Voir Utilisation récursive de make. (En pratique, il est rarement nécessaire d'indiquer cette option, car ‘make’ le fait automatiquement à votre place ; voir L'option ‘--print-directory’.)
Désactive l'affichage du répertoire de travail sous -w. Cette option est utile lorsque -w est activé automatiquement mais que vous ne voulez pas voir ces messages supplémentaires. Voir L'option ‘--print-directory’.
Fait comme si la cible file venait tout juste d'être modifiée. Utilisé avec le drapeau ‘-n’, cela vous permet de voir ce qui se passerait si vous modifiiez ce fichier. Sans ‘-n’, cela revient à peu près à exécuter une commande touch sur le fichier indiqué avant de lancer make, à ceci près que la date de modification ne change que dans l'imagination de make. Voir Au lieu d'exécuter les recettes.
Émet un message d'avertissement chaque fois que make rencontre une référence à une variable non définie. Cela peut être utile lorsque vous essayez de déboguer des makefiles qui utilisent les variables de façon complexe.