Comment utiliser -DDEBUG du Makefile et les directives du préprocesseur ?

Bonsoir, je voudrais utiliser -DDEBUG qui est dans mon Makefile et que cela ait une incidence sur les directives du préprocesseur dans les fichiers *.c

Ce que je voudrais faire, c'est si dans un .c j'ai un assert ou un printf, lors de la compilation finale les assert et les messages soient désactivés.

Donc par exemple si j'ai dans mon Makefile j'ai :

Code:

---

1 2	COPTS = -c -g -W -Wall -Werror -pedantic -O3 -DDEBUG

---

en mettant -DDEBUG le message de mon .c :

Code:

---

1 2 3 4

#ifdef DEBUG printf("w=%d / h=%d",board->w,board->h); #endif

---

je voudrais qu'il soit désactivé. Mais si je met -DEBUG je réactive mon printf.
Le problème c'est que cela ne marche pas.


Merci par avance pour votre aide.

Citation:

---

Envoyé par hbx360

Code:

---

COPTS = -c -g -W -Wall -Werror -pedantic -O3 -DDEBUG

---

---

Bonjour

Ca ne fonctionnera que si tu indiques, dans ton Makefile, qu'il faut utiliser la variable "COPTS" lorsque tu compiles.

Comme tu as mis l'option "-c", ça veut dire que tu veux générer un ".o" donc tu dois écrire la règle de création d'un ".o" à partir d'un ".c"

Code:

---

1 2	.c.o: $(CC) $(COPTS) $< -o $@

---

Maintenant, il faut la règle pour générer un exécutable à partir d'un ".o"

Code:

---

1 2	.o: $(CC) $< -o $@

---

Et si tu veux passer directement du ".c" à l'exécutable, il faut alors là aussi écrire une règle. Tu peux alors regrouper les deux règles précédentes

Code:

---

1 2 3 4

.c: $(CC) $(COPTS) $< -o $*.o $(CC) $*.o -o $@ rm -f $*.o

---

Mais ça oblige ensuite, si une des options change, de la reporter partout où elle est utilisée. Tu peux sinon indiquer au Makefile de se réutiliser lui-même pour générer d'abord le ".o" puis l'exécutable à partir du ".o"

Code:

---

1 2 3 4

.c: $(MAKE) $*.o $(MAKE) $@ rm -f $*.o

---

Et dans ce cas, quand le Makefile rappelle make, il utilise alors les règles déjà écrites pour les opérations demandées.

Plus de détails sur le Makefile ici.

Merci Sve@r pour ton aide mais en faite ce que je veux c'est pouvoir utiliser -DEBUG ou -DDEBUG que j'ai mis dans mon COPTS pour activer ou désactiver le printf comme indiquer dans mon premier message.

Apparement le DEBUG du lien que tu m'as donné concerne uniquement le makefile ce que je voudrais c'est qu'on puisse l'utiliser dans un .c ou un .h

Mon Makefile est comme suite :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

CC=gcc COPTS = -c -g -W -Wall -Werror -pedantic -O3 -DEBUG OBJS=main.o global.o init_SDL.o event.o loadSprites.o tools.o   life : $(OBJS) $(CC) $(OBJS) -o life -L/usr/local/lib -lSDLmain -lSDL   main.o : main.c global.h init_SDL.h event.h loadSprites.h tools.h $(CC) $(COPTS) main.c   global.o : global.c global.h tools.h init_SDL.h event.h $(CC) $(COPTS) global.c   init_SDL.o : init_SDL.c init_SDL.h tools.h $(CC) $(COPTS) init_SDL.c   event.o : event.c event.h tools.h $(CC) $(COPTS) event.c   loadSprites.o : loadSprites.c loadSprites.h tools.h $(CC) $(COPTS) loadSprites.c   tools.o : tools.c tools.h $(CC) $(COPTS) tools.c   clean : rm -f *.o *~ *.stackdump *.exe \#*\#

---

Bonjour
-DEBUG définit la macro EBUG, pour ce que tu veux faire il faut un -DDEBUG.

C'est un flag destiné au préprocesseur, ces flags sont généralement mis dans la variable CPPFLAGS pour pouvoir bénéficier des avantages des règles automatiques.

Tu pourrais changer d'optique et préférer d'utiliser une macro NDEBUG, en gros faire le contraire de ce que tu fais. Cela est intéressant dans le sens que cette macro est utilisé par la libc pour les assert.

Citation:

---

Envoyé par picodev

...pour ce que tu veux faire il faut un -DDEBUG.

---

En plus il l'avait bien mis ainsi dans son premier message (j'y avais pensé aussi et avais alors bien checké le truc)...

Merci pour votre aide.

Je n'ai toujours pas compris comment marche -DDEBUG dans le makefile si quelqu'un avait un p'tit exemple a me donner.

Comment faire pour que -DDEBUG prennent en compte mon DEBUG dans mon fichier.c

C'est pourtant très simple :mrgreen: -DXXX équivaut à un #define XXX 1.

Donc lorsque tu spécifies -DDEBUG, tu fais un #define DEBUG 1.

Et donc dans ce code tu vas faire un printf ;) ;)

Code:

---

1 2 3 4 5 6 7

int i;   i = computeValue();   #ifdef DEBUG printf("Debug - i: %d\n", i); #endif // DEBUG

---

Ce n'est pas dans le makefile que la magie opère. C'est simplement l'option -D avec pour argument DEBUG que tu donnes à ton compilateur. Cette option va définir la macro DEBUG comme la valeur 1. En gros si tu as -DDEBUG sur la ligne de commande de gcc c'est comme si tu avais #define DEBUG 1 au début de tous les fichiers passant par le préprocesseur.
Cela te permet de faire de la compilation conditionnelle :

Code:

---

1 2 3 4 5 6 7 8

... # if DEBUG // code compilé uniquement si DEBUG existe et vaut 1 # else // code compilé uniquement si DEBUG n'existe pas ou vaut 0 # endif // DEBUG ...

---

Tu as plus d'explications sur -D dans la doc gcc.

Essaye néanmoins d'utiliser les variables classiques CPPFLAGS, CFLAGS, …
Tu peux aussi tirer avantages des règles par défaut.

La libc utilise la macro NDEBUG dans ce cas de figure … peut-être pourrais-tu l'utiliser et en tirer parti si tu utilises les assert.

Merci beaucoup pour toutes vos explications qui me seront bien utile et pour votre aide et d'avoir pris de votre temps.

Je pense que j'ai compris maintenant.

Sinon j'avais réfléchi a une autre solution sans passer par le makefile : c'était de mettre dans un include.h par exemple ou fichier four tout, d'y mettre un #define et de changer celui-ci en rajoutant une lettre par exemple un D au début pour ne plus voir mes messages conditionnel.

Il y a un autre avantage à passer par un Makefile : pouvoir passer des arguments en ligne de commande.
Par exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

CC = gcc CPPFLAGS = ... CFLAGS = ... LDFLAGS = ... LDLIBS = ....   # ici DEBUG est une variable makefile # ?= signifie «si DEBUG n'est pas définie alors par défaut elle vaut 1» DEBUG ?= 1 ...   # si DEBUG vaut 1 ifeq (1,$(DEBUG)) CPPFLAGS += -DDEBUG CFLAGS += -g ... else CPPFLAGS += -DNDEBUG CFLAGS += -O3 ... endif

---

En ligne de commande tu pourras directement choisir : compiler en mode debug : make équivalent à make DEBUG=1 ou compiler en mode release make DEBUG=0. Mais attention, avant de changer une compilation de debug à release il faut faire un clean complet.

C'est un peu ce qui est fait dans le projet Makefile générique, mais le concept est poussé un peu plus loin.

Mais sinon oui, cela revient en gros à créer un header que tu inclues PARTOUT. Cette dernière méthode a un avantage → pas besoin de clean complet, mais il ne faut pas oublier d'inclure ton header PARTOUT.L'inconvénient est qu'à chaque modif de ce header tout sera regénéré.

Pour qu'ensuite le commentaire ne s'affiche plus dans mon .c, que dois-je mettre à la place de -DDEBUG ? dois-je mettre -NDEBUG ?

@picodev :

Citation:

---

Mais sinon oui, cela revient en gros à créer un header que tu inclues PARTOUT. Cette dernière méthode a un avantage → pas besoin de clean complet, mais il ne faut pas oublier d'inclure ton header PARTOUT.L'inconvénient est qu'à chaque modif de ce header tout sera regénéré.

---

Oui c'est le problème ; la première solution est celle qui reste la plus viable par le makefile.

Citation:

---

Essaye néanmoins d'utiliser les variables classiques CPPFLAGS, CFLAGS, …
Tu peux aussi tirer avantages des règles par défaut.

---

En faite je ne sais pas me servir de CPPFLAGS, ni CFLAGS, je reste un novice sur le makefile.
Il faudrait que je prenne le temps de me renseigner a ce sujet.

Citation:

---

Pour qu'ensuite le commentaire ne s'affiche plus dans mon .c, que dois-je mettre à la place de -DDEBUG ? dois-je mettre -NDEBUG ?

---

Je me réponds à moi même :aie: :

Tu dois enlever le D donc faire :

Code:

---

-DEBUG

---

puis faire un make clean

Citation:

---

Envoyé par hbx360

Tu dois enlever le D donc faire :

Code:

---

-DEBUG

---

---

Ben non, là tu définis une macro "EBUG" inutile. Enfin oui le résultat correspond à ce que tu attends puisque la macro "DEBUG" n'existe plus mais la façon de faire est totalement nulle.
Tu peux soit supprimer le "-DDEBUG" de ton Makefile, soit remplacer "-DDEBUG" par "-UDEBUG"...

Ok Merci pour l'info qui me manquais je ne connaissais pas le -Uxxxx mais faut quand même faire un make clean pour que le -Uxxx soit pris en compte c'est dommage.

Citation:

---

Envoyé par hbx360

Ok Merci pour l'info qui me manquais je ne connaissais pas le -Uxxxx mais faut quand même faire un make clean pour que le -Uxxx soit pris en compte c'est dommage.

---

Pour info également :

• « -D » → #define ;
• « -U » → #undef.

Il y a plusieurs choses à comprendre. Si tu regardes le code C que j'ai posté un peu plus haut tu remarqueras que j'utilise un #if DEBUG au lieu d'un #ifdef DEBUG. Cela a une importance.
Quand le préprocesseur rencontre un token qu'il ne connaît pas alors il le remplace simplement par 0 (faux). Comme je l'ai marqué en commentaire un #if DEBUG n'est «vrai» que si non seulement DEBUG est défini mais aussi si sa valeur est non nulle. Il est souvent préférable de faire ainsi car tout ou tard quelqu'un finira par faire un #define DEBUG 0 ou placer un -D DEBUG=0 et même si la valeur de la macro est 0 elle sera définie.
J'ai l'impression aussi que tu as du mal avec l'option -D. Ce n'est qu'une option et si tu préfères tu peux mettre une espace entre l'option et le symbole que tu définis : -D DEBUG est équivalent à -DDEBUG.

Ensuite makefile a des règles implicites pour certaines cibles. Par exemple pour compiler un fichier terminant en .c et pour obtenir le fichier objet il y a la règle $(CC) $(CFLAGS) $(CPPFLAGS) -c $<. Cette règle signifie : si je dois construire un .o à partir d'un .c alors j'exécute cette commande. La variable CC contient le compilateur (gcc), CFLAGS les options pour le compilateur C , CPPFLAGS celles pour le préprocesseur (C PreProcessor FLAGS) et $< est la première dépendance.
Cela signifie que si tu utilises ces variables, tu peux uniquement indiquer les dépendances sans avoir à donner une ligne de commandes à exécuter :

Au lieu de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

CC=gcc COPTS = -c -g -W -Wall -Werror -pedantic -O3 -DEBUG OBJS=main.o global.o init_SDL.o event.o loadSprites.o tools.o   life : $(OBJS) $(CC) $(OBJS) -o life -L/usr/local/lib -lSDLmain -lSDL   main.o : main.c global.h init_SDL.h event.h loadSprites.h tools.h $(CC) $(COPTS) main.c   global.o : global.c global.h tools.h init_SDL.h event.h $(CC) $(COPTS) global.c   init_SDL.o : init_SDL.c init_SDL.h tools.h $(CC) $(COPTS) init_SDL.c   event.o : event.c event.h tools.h $(CC) $(COPTS) event.c   loadSprites.o : loadSprites.c loadSprites.h tools.h $(CC) $(COPTS) loadSprites.c   tools.o : tools.c tools.h $(CC) $(COPTS) tools.c   clean : rm -f *.o *~ *.stackdump *.exe \#*\#

---

tu aurais

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

CC=gcc CPPFLAGS = -D DEBUG CFLAGS = -g -Wextra -Wall -Werror -pedantic LDFLAGS = -L/usr/local/lib #ici les options de recherche pour les répertoires des bibliothèques LDLIBS = -lSDLmain -lSDL # les bibliothèques à lier   OBJS=main.o global.o init_SDL.o event.o loadSprites.o tools.o   life : $(OBJS)   main.o : main.c global.h init_SDL.h event.h loadSprites.h tools.h   global.o : global.c global.h tools.h init_SDL.h event.h   init_SDL.o : init_SDL.c init_SDL.h tools.h   event.o : event.c event.h tools.h   loadSprites.o : loadSprites.c loadSprites.h tools.h   tools.o : tools.c tools.h   .PHONY: clean clean : $(RM) $(OBJS) *~ *.stackdump *.exe \#*\#

---

L'option -W est dangereuse … et obsolète. Elle est remplacée par -Wextra. Elle est dangereuse car il y a l'option -w (w minuscule) qui est très proche et qui supprime tous les warnings.
Quel intérêt d'utiliser à la fois -g (option pour debug) et -O3 (option pour optimiser à fond) ? Si tu debugues ainsi tu peux avoir de drôles d'effets. Très souvent c'est soit l'un soit l'autre.
Les cibles qui ne créent pas de fichiers (comme clean) doivent être déclarée en phony. Cela évite que le jour où par mégarde tu crées un fichier nommé clean cette cible ne soit plus exécutée.

@Obsidian Merci pour ta réponse.

Merci beaucoup @picodev pour tous ces renseignements que tu m'as donné, le temps que tu prends à me répondre et le temps que tu prends pour me donné des info supplémentaires.

en ce qui concerne le COPTS :

Citation:

---

-c -g -W -Wall -Werror -pedantic -O3 -DEBUG

---

que j'ai mis dans mon makefile, c'est en regardant des cours en C sur youtube le gars faisait comme ça donc j'ai fait comme lui ; bien sûr ces options de compilation je me suis quand même renseigner sur ce que c'était mais je n'ai pas forcément approfondie le sujet puisque ça marchait.

Citation:

---

Envoyé par picodev

Les cibles qui ne créent pas de fichiers (comme clean) doivent être déclarée en phony. Cela évite que le jour où par mégarde tu crées un fichier nommé clean cette cible ne soit plus exécutée.

---

Ca je ne savais pas... 8-) :plusser:

Citation:

---

Envoyé par hbx360

c'est en regardant des cours en C sur youtube

---

Mouais. Il y a mieux comme site d'apprentissage de la prog...

Citation:

---

Envoyé par Sve@r

Mouais. Il y a mieux comme site d'apprentissage de la prog...

---

Si des fois on trouve des cours pas trop mal fait j'ai beaucoup appris avec certaine chaine youtube.