Commandes et règles (explicites et implicites) de MAKE
Remonter à MAKE.EXE
Vous écrivez des règles explicites et implicites indiquant à MAKE comment construire les cibles de votre fichier make. En général, ces règles sont les suivantes :
- Les règles explicites sont des instructions applicables à certains fichiers.
- Les règles implicites sont des instructions générales applicables aux fichiers non concernés par les règles explicites.
Toutes les règles que vous écrivez doivent respecter le format général suivant :
Dependency line Command line
Alors que la ligne de dépendance utilise une syntaxe différente pour les règles explicites et pour les règles implicites, la syntaxe de la ligne de commande est la même pour les deux types de règles.
MAKE supporte les lignes de dépendance multiples pour une même cible et une même cible peut avoir plusieurs lignes de commande. Toutefois, seule une ligne de dépendance peut contenir une ligne de commande apparentée. Par exemple :
Target1: dependent1 dep2 dep3 dep4 dep5
Target1: dep6 dep7 dep8
bcc32 -c $**
Sommaire
Syntaxe des règles explicites
Les règles explicites spécifient les instructions que MAKE doit respecter lors de la construction de cibles spécifiques. Les règles explicites nomment une ou plusieurs cibles suivies par un ou deux signes deux-points. Un seul signe deux-points signifie qu'une seule règle est écrite pour la ou les cibles ; deux signes deux-points signifient que deux règles ou plus sont écrites pour la ou les cibles.
Les règles explicites suivent cette syntaxe :
<target> [<target>...]:[:][{<path>}] [<dependent[s]>...]
[<commands>]
| Elément | Description |
|---|---|
<cible> |
Spécifie le nom et l'extension du fichier à construire (une cible doit commencer une ligne dans le fichier make -- vous ne pouvez pas faire précéder le nom de la cible par des espaces ni par des tabulations). Pour spécifier plusieurs cibles, séparez les noms des cibles par des espaces ou des tabulations. Egalement, vous ne pouvez pas utiliser un nom de cible plusieurs fois à l'emplacement d'une cible dans une règle explicite. |
<chemin> |
Est une liste de répertoires indiquant à MAKE où trouver les fichiers dépendants. Séparez les répertoires multiples par des points-virgules et entourez la spécification du chemin complet entre accolades. |
<dépendant> |
Est le ou les fichiers dont MAKE vérifie la date et l'heure pour savoir s'ils sont plus récents que la |
<commandes> |
N'importe quelle commande du système d'exploitation. Vous devez indenter la ligne de commandes d'au moins un espace ou une tabulation, sinon elle serait interprétée comme une cible. Séparez les commandes multiples par des espaces. |
Si une ligne de dépendance ou de commande se poursuit sur la ligne d'après, utilisez une barre oblique inversée \ à la fin de la première ligne pour indiquer que la ligne se continue. Par exemple :
MYSOURCE.EXE: FILE1.OBJ\ #Dependency line
FILE3.OBJ #Dependency line continued
bcc32 file1.obj file3.obj #Command line
Cibles uniques avec règles multiples
Une même cible peut avoir plusieurs règles explicites. Pour spécifier plusieurs règles explicites, utilisez deux signes deux-points :: après le nom de la cible.
L'exemple suivant montre des cibles comportant plusieurs règles et commandes :
.cpp.obj: bcc32 -c -ncobj $< .asm.obj: tasm /mx $<, asmobj\ mylib.lib :: f1.obj f2.obj #double colon specifies multiple rules echo Adding C files tlib mylib -+cobjf1 -+cobjf2 mylib.lib :: f3.obj f4.obj echo Adding ASM files tlib mylib -+asmobjf3 -+asmobjf4
Syntaxe des règles implicites
Une règle implicite est une règle générale sur la façon dont MAKE construit les fichiers utilisant des extensions de fichier particulières. Les règles implicites commencent soit par un chemin d'accès soit par un point. Leurs composants principaux sont des extensions de fichier séparées par des points. La première extension appartient au dépendant, la seconde à la cible.
Si les dépendants implicites ne sont pas à jour par rapport à la cible ou s'il n'existe pas de dépendants, MAKE exécute les commandes associées à la règle. MAKE met à jour les dépendants explicites avant de mettre à jour les dépendants implicites.
Les règles implicites suivent cette syntaxe :
[{>source_dir>}].<source_ext>[{target_dir}].<target_ext>:
[<commands>]
| Elément | Description |
|---|---|
<source_rép> |
Spécifie le ou les répertoires contenant les fichiers dépendants. Vous pouvez spécifier plusieurs répertoires en les séparant par un point-virgule. |
.<source_ext> |
Spécifie l'extension des noms de fichier dépendant. |
<cible_rép> |
Spécifie le répertoire où MAKE place les fichiers cible. La règle implicite sera uniquement utilisée pour les cibles dans ce répertoire. Sans spécification d'un répertoire cible, les cibles de n'importe quel répertoire satisferont la règle implicite. |
.<cible_rép> |
Spécifie l'extension des noms de fichier cible. Les macros sont autorisées ici. |
: (deux-points) |
Marque la fin de la ligne de dépendance. |
<commandes> |
N'importe quelle commande du système d'exploitation. Vous devez indenter la ligne de commande d'au moins un espace ou une tabulation ; sinon elle serait interprétée comme une cible. |
Si deux règles implicites correspondent à une extension de cible et s'il n'existe pas de dépendant, MAKE utilise la règle implicite dont l'extension des dépendants apparaît en premier dans la liste .SUFFIXES.
Règles explicites et commandes implicites
Une cible dans une règle explicite peut prendre sa ligne de commandes dans une règle implicite. L'exemple suivant montre une règle implicite suivie d'une règle explicite sans ligne de commande :
c.obj: bcc32 -c $< #Cette commande utilise un macro $< décrit ultérieurement myprog.obj: #Cette règle explicite utilise la commande : bcc32 -c myprog.c
La commande de la règle implicite indique à MAKE de compiler MYPROG.C (la macro $< remplace le nom myprog.obj par myprog.c).
Syntaxe de la commande MAKE
Les commandes suivent immédiatement une règle explicite ou implicite et doivent commencer sur une nouvelle ligne avec un espace ou une tabulation. Les commandes peuvent être n'importe quelle commande du système d'exploitation, mais elles peuvent également inclure des macros et directives MAKE, ainsi que des opérateurs spéciaux non reconnus par les systèmes d'exploitation (notez toutefois que vous ne pouvez pas utiliser le caractère | dans les commandes).
Voici quelques exemples de commandes :
cd.. bcc32 -c mysource.c COPY *.OBJ C:\PROJECTA bcc32 -c $(SOURCE) #Macros in "Using MAKE macros"
La syntaxe des commandes est la suivante :
[<prefix>...] <commands>
Préfixes des commandes
Les commandes des règles implicites et explicites peuvent disposer de préfixes qui modifient la façon dont MAKE traite les commandes. Le tableau suivant liste les préfixes utilisables dans les fichiers make :
| Préfixe | Description |
|---|---|
@ |
N'affiche pas la commande en cours d'exécution. |
-<num> |
Arrête le traitement des commandes du fichier make si le code de sortie renvoyé par la commande est supérieur à l'entier |
- |
Continue le traitement des commandes du fichier make, quel que soit les codes de sortie renvoyés. |
& |
Interprète soit la macro |
! |
Se comporte comme le préfixe |
Utilisation de @
La commande suivante utilise le préfixe @ qui empêche MAKE d'afficher la commande à l'écran :
diff.exe : diff.obj @bcc32 diff.obj
Utilisation-<num> et de -
Les préfixes -<num> et - (tiret) contrôlent le traitement du fichier make en cas d'erreur. Vous pouvez choisir de poursuivre le traitement de MAKE si une erreur se produit ou spécifier un nombre d'erreurs à tolérer.
Dans l'exemple suivant, MAKE poursuit son traitement si BCC32 renvoie des erreurs :
target.exe : target.obj
target.obj : target.cpp
-bcc32 -c target.cpp
Utilisation &
Le préfixe & émet une commande une fois par fichier dépendant. Il est très utile pour les commandes qui n'acceptent pas de liste de fichiers comme paramètres. Par exemple :
copyall : file1.cpp file2.cpp
© $** c:\temp
invoque COPY deux fois, comme suit :
copy file1.cpp c:\temp copy file2.cpp c:\temp
Sans le modificateur & vaurait appelé la commande COPY une seule fois.
Remarque : Le préfixe
&ne fonctionne qu'avec les macros$**et$!.
Opérateurs de la commande MAKE
Alors que vous pouvez utiliser n'importe quelle commande du système d'exploitation dans une section de la commande MAKE, vous pouvez également utiliser les opérateurs spéciaux suivants :
| Opérateur | Description |
|---|---|
< |
Prendre les entrées de commande dans le fichier spécifié plutôt que dans l'entrée standard. |
> |
Envoyer la sortie de la commande dans le fichier. |
>> |
Ajouter la sortie de la commande dans le fichier. |
<< |
Créer un fichier inline temporaire et utiliser son contenu comme entrée standard de la commande. Créer également un fichier de réponse temporaire lorsque -N est utilisé. Remarque : cela n'est utilisé qu'avec NMAKE de Microsoft. |
&& |
Créer un fichier de réponse temporaire et insérer son nom dans le fichier make. |
<delimiter> |
Utiliser des délimiteurs avec les fichiers de réponse temporaires. Vous pouvez utiliser n'importe quel caractère différent de |