Directives MAKE

De RAD Studio
Aller à : navigation, rechercher

Remonter à MAKE.EXE


Les directives de MAKE ressemblent aux directives des langages tels que Pascal et C. Dans MAKE, elles effectuent diverses opérations de contrôle, telles que l'affichage des commandes avant leur exécution. Les directives de MAKE commencent par un point ou par un point d'exclamation, et remplacent les options données sur la ligne de commande. Les directives qui commencent par un point d'exclamation doivent apparaître au début d'une nouvelle ligne.

Directives MAKE Directives et leurs options de ligne de commande

Le tableau suivant donne la liste des directives de MAKE et leur options en ligne de commande correspondantes :

Directive Option (si disponible) Description/Exemple

.autodepend

-a

Active le contrôle de l'auto-dépendance.. Les auto-dépendances sont les fichiers automatiquement inclus dans les cibles que vous construisez, comme les fichiers en-tête inclus dans votre code source C++. Si .autodepend est actif, MAKE compare les dates et heures de tous les fichiers utilisés pour construire le .OBJ, y compris les fichiers d'auto-dépendance. Si les dates et heures des fichiers utilisés pour construire le .OBJ sont plus récentes que la date et heure du fichier .OBJ, le fichier .OBJ est recompilé. Vous pouvez utiliser ..autodepend (ou -a) à la place des dépendances liées.

.cacheautodepend

-c

Active l'auto-dépendance en mémoire cache

!cmdswitches

Utilisez + ou - suivi des lettres d'option non chaîne pour activer ou désactiver chaque option. Les espaces et tabulations doivent apparaître avant l'opérateur + ou -, aucun ne devant apparaître entre l'opérateur et les lettres de l'option.

!elif

Equivalent du else if de C.

!else

Equivalent du else de C.

!endif

Termine une instruction !if, !ifdef ou !ifndef.

!error

Arrête MAKE et affiche un message d'erreur. La syntaxe de la  !error directive est :

!error <message>

MAKE s'interrompt et affiche la chaîne suivante lorsqu'il rencontre cette directive : Fatal makefile exit code: Erreur de directive - <message>

Imbriquez !error dans les instructions conditionnelles pour arrêter le traitement et afficher un message d'erreur, comme cela est montré dans l'exemple suivant :

!if !$d(MYMACRO) #si MYMACRO n'est pas définie 
 !error MYMACRO n'est pas définie 
 ! endif

Si MYMACRO n'est pas définie, MAKE s'interrompt et affiche :

Fatal makefile 4: Erreur de directive - MYMACRO n'est pas définie

Contrôles d'erreur

MAKE offre quatre contrôles d'erreur différents contrôles :
  • La directive .ignore désactive le contrôle d'erreur pour la partie sélectionnée du fichier make.
  • L'option en ligne de commande -i désactive le contrôle d'erreur pour tout le fichier make.
  • Le préfixe -num, saisi comme partie intégrante d'une règle, désactive le contrôle d'erreur pour la commande associée si le code de sortie dépasse le nombre spécifié.
  • Le préfixe - désactive le contrôle d'erreur pour la commande associée quel que soit le code de sortie.

!if

Commence une instruction conditionnelle.

!ifdef

Equivalent du #ifdef de C, en testant si la macro a été définie.

!ifndef

Equivalent du #ifndef de C, en testant si la macro est non définie.

.ignore

-i

MAKE ignore la valeur de retour d'une commande.

!include

Cette directive est semblable à la directive #include du préprocesseur pour le langage C ou C++ -- elle vous permet d'inclure le texte d'un autre fichier dans le makefile :

!include <nomfichier>

Vous pouvez délimiter le nom du fichier avec des guillemets " " ou des crochets angulaires < > et imbriquer les directives dans un niveau de profondeur illimité.

Cependant, l'écriture de directives !include dupliquées dans un makefile n'est pas autorisée -- vous obtiendrez le message d'erreur de boucle dans le fichier d'inclusion.

Les règles, les commandes ou les directives doivent être terminées dans un fichier source unique ; vous ne pouvez pas démarrer une commande dans un fichier !include, puis la terminer dans le makefile. MAKE recherche les fichiers !include dans le répertoire en cours, à moins que vous n'ayez spécifié un autre répertoire avec l'option de ligne de commande -I.

.keep

-K

Conserve les fichiers temporaires créés par MAKE (MAKE les supprime habituellement).

!message

Envoie un message vers stdout pendant que MAKE exécute le fichier make.

La directive !message permet d'afficher des messages à l'écran depuis un fichier make. Ces messages vous servent à déboguer un fichier make qui ne fonctionne pas comme vous le souhaiteriez. Par exemple, si une définition de macro vous pose des problèmes, insérez cette ligne dans le fichier make :

!message La macro est définie comme : $(MacroName)

Lorsque MAKE interprète cette ligne, il affiche à l'écran (en supposant que la macro s'exprime en .CPP) :

La macro est définie comme : .CPP

.noautodepend

-a-

Désactive le contrôle de l'auto-dépendance.

.nocacheautodepend

-c-

Désactive l'auto-dépendance en mémoire cache.

.noIgnore

-i-

Désactive .Ignore.

.nokeep

-K-

Ne conserve pas les fichiers temporaires créés par MAKE.

.nosilent

-s-

Affiche les commandes avant que MAKE ne les exécute.

.noswap

-S-

Indique à MAKE de ne pas sortir de la mémoire avant d'exécuter une commande.

.path.ext

Indique à MAKE de rechercher les fichiers avec l'extension ..ext dans les répertoires du chemin

Pour indiquer à MAKE que les fichiers .c sont dans C:\SOURCE ou dans C:\CFILES et que les fichiers .obj sont dans C:\OBJS :

.path.c = C:\CSOURCE;C:\CFILES .path.obj = C:\OBJS

.precious

Enregistre les cibles même si la construction échoue.

Si une construction de MAKE échoue, le fichier cible est supprimé. La directive .precious interdit la suppression des fichiers, ce qui peut être souhaitable dans le cas de certaines cibles. Par exemple, si votre construction échoue dans l'ajout d'un module dans une bibliothèque, votre désir ne sera pas forcément de supprimer la bibliothèque. La syntaxe de .precious est :

.precious: <cible> [<target>...]

.silent

-s

MAKE exécute les commandes sans les afficher en premier.

.suffixes

Définit la règle implicite pour les dépendances ambiguës. La directive .suffixes indique à MAKE l'ordre (par extension de fichier) de construction des règles implicites. La syntaxe de .suffixes est :

.suffixes: .<ext> [.<ext> ...]

.&.<ext> représente l'extension du fichier dépendant dans les règles implicites.

Par exemple, vous pouvez inclure la ligne .suffixes: .asm .c .cpp pour dire à MAKE d'interpréter les règles implicites en commençant par celles qui dépendent de fichiers .ASM, puis .C, .CPP, quel que soit leur ordre dans le fichier make.

L'exemple suivant de .suffixes indique à MAKE de rechercher un fichier source avec une extension .ASM, puis avec l'extension .C, et finalement avec l'extension .CPP. Si MAKE trouve MYPROG.ASM, il construit MYPROG.OBJ à partir du fichier assembleur en appelant TASM. MAKE appelle alors ILINK32 ; sinon, MAKE recherche MYPROG.C pour construire le fichier .OBJ où il recherche MYPROG.CPP.

.suffixes: .asm .c .cpp 
myprog.exe: myprog.obj
bcc32 myprog.obj
.cpp.obj: 
bcc32 -P -c $<
.asm.obj: 
tasm /mx $
.c.obj:
bcc32 -P- -c $<

.swap

-S

Indique à MAKE de sortir de la mémoire avant d'exécuter une commande.

!undef

Efface la définition d'une macro. Après cela, la macro n'est pas définie. La directive !undef (undefine) provoque un échec du test !ifdef MacroName.


La syntaxe de la directive !undef est : !undef MacroName


Utilisation de macros dans les directives

La macro $d est utilisée avec la directive conditionnelle  !if pour effectuer certains traitements si une macro spécifique est définie. $d est suivie d'un nom de macro entre parenthèses ou entre accolades, comme dans l'exemple ci-dessous :

!if $d(DEBUG)            #If DEBUG is defined,
bcc32 -v f1.cpp f2.cpp   #compile with debug information;
!else                    #otherwise
bcc32 -v- f1.cpp f2.cpp   #don't include debug information.
!endif

Macros Null

Tandis qu'un nom de macro non définie détérmine un test !ifdef MacroName à renvoyer false, MacroName défini comme null va renvoyer true. Vous définissez une macro null en plaçant après le signe =, dans la définition de la macro, soit des espaces, soit un caractère de passage. Par exemple, la ligne suivante définit une macro null d'un fichier make :

NULLMACRO =

La ligne suivante définit une macro vide sur la ligne de commande de MAKE :

NULLMACRO =""
-DNULLMACRO

 !if et autres directives conditionnelles

La directive !if fonctionne de la même manière que l'instruction if du C. Comme illustré ci-dessous, la syntaxe de !if et des autres directives conditionnelles ressemble à celle des instructions conditionnelles du compilateur :

!if condition

!if condition

!if condition

!ifdef macro

!endif

!else

!elif condition

!endif

!endif

!endif


Les expressions suivantes sont équivalentes :

!ifdef macro /* is equivalent to */ !if $d(macro)
ifndef macro /* is equivalent to */ !if !$d(macro) 

Ces règles s'appliquent aux directives conditionnelles :

  • Une directive !else est autorisée entre les directives !if, !ifdef ou !ifndef et !endif.
  • Plusieurs directives !elif sont autorisées entre les directives !if, !ifdef ou !ifndef, !else et !endif.
  • Vous ne pouvez pas répartir de règles entre plusieurs directives conditionnelles.
  • Vous pouvez imbriquer les directives conditionnelles.
  • !if, !ifdef, et !ifndef doivent correspondre à des directives !endif dans le même fichier.

Les informations suivantes peuvent être insérées entre les directives !if et !endif :

  • Définition de macro
  • Règle explicite
  • Règle implicite
  • Directive include
  •  Directive !error
  •  Directive !undef

Dans une instruction if, l'expression conditionnelle consiste en une constante décimale, octale ou hexadécimale suivie des opérateurs du tableau suivant :

Opérateur Description Opérateur Description

-

Négation

?:

Expression conditionnelle

~

Complément de bit

!

NOT logique

+

Addition

>>

Décalage à droite

-

Soustraction

<<

Décalage à gauche

*

Multiplication

&

AND bit-à-bit

/

Division

|

OR bit-à-bit

%

Reste

^

XOR bit-à-bit

&&

AND logique

>+

Supérieur ou égal à *

||

OR logique

<+

Inférieur ou égal à *

>

Supérieur à

==

Egalité *

<

Inférieur à

!=

Inégalité *

L'opérateur marquée avec le signe * fonctionne également avec les expressions de type chaîne.

MAKE évalue une expression conditionnelle comme un entier signé 32 bits ou une chaîne de caractères.

Voir aussi