Macro qui définit une macro?

Bonjour,

Pour mon projet, j'utilise un système de trace très simple qui est défini via une macro:

Code:

---

#define TRACE(X) do{ printf("[nom du module] "); (X);} while(0)

---

Par flemme, j'ai pas envie de réécrire ca à chaque fois dans chaque module. Ce que j'aimerais, c'est avoir une macro qui me définit cette macro (fiou)!

Du genre:

Code:

---

#define DEFTRACE(A) #define TRACE(X) do{printf((A)); (X);}while(0)

---

Que j'utiliserais ainsi:

Code:

---

DEFTRACE("Nom du module ")

---

Le problème (haha) c'est la présence du #, évidemment. J'obtiens une erreur: `#' operator should be followed by a macro argument name

Comme mon compilo est pour l'embarqué, je ne peux pas utiliser des macro à nombre d'arguments variable.

Savez vous si c'est possible (sans forcément entrer dans le débat: fais une fonction à la place) de définir une macro dans une autre macro?


Merci d'avance!

La première macro fonctionne ??

Le while(0) me parait un peut flou (puisque la condition sera fausse donc il va sortir tout de suite... bref...

Code:

---

1 2	#define DEFTRACE(A) #define TRACE(X) do{printf((A)); (X);}while(0)

---

Ne peut pas fonctionner, tu ne peux pas faire deux #blabla sur une même ligne.

Il faudrait que tu fasse :

Code:

---

1 2	#define DEFTRACE(X, TEXT) do{printf((TEXT)); (X);}while(0)

---

Mais il me semble qu'il y ai un système particulier pour l'utilisation de texte dans une macro.
Dans tous les cas ta première macro "TRACE" ne prend qu'un "paramètre" elle ne peut donc pas accueillir une variable X et une variable de TEXTE à mettre dans le printf.

Cela étant dit les macros ne sont pas mon fort...
J'espère que quelqu'un d'autre pourra mieux t'aider que moi, ou tout du moins mieux t'indexer vers une autre solution.

Bonne chance ;)

Citation:

---

Envoyé par rilou

Le while(0) me parait un peut flou (puisque la condition sera fausse donc il va sortir tout de suite... bref...

---

C'est la technique classique pour faire des macros multiinstructions ;)

Pour la question, bein il suffit de modifier la macro pour qu'elle prenne le texte en paramètre, comme l'a montré rilou.

A part ça, le premier argument de printf est une chaine de format et non une chaine à afficher, gardez ça en tete

Pour l'instant, j'utilise TRACE tout court, ainsi:

Code:

---

1 2 3 4

#define TRACE(X) do{ printf("[Mon Module] "); (X);} while(0) //.... TRACE(printf("Mon log\n"));

---

Affiche dans la console:

Citation:

---

[Mon Module] Mon Log

---

En suivant votre idée donc, il faudrait que je fasse quoi?

Code:

---

1 2 3

#define TRACE(X,Y) do{ printf((X)); (Y);} while(0) #define DEFTRACE(X) TRACE("MonNomDeModule",(X))

---

?

Oui, par exemple

Au fait, vous avez les constantes symboliques standards __FILE__ et __LINE__ si vous voulez vous passer d'indiquer le module (si c'est ça que vous vouelz faire)

Oui je connais déjà __FILE__ et __LINE__, j'ai fait une macro dédiée à ceux là.

Mais comme mon makefile va chercher ces fichiers dans une arborescence (modules/nomDuModule/src/fichier.c), ca rend rapidement les logs illisibles (puisque __FILE__ inclus le chemin "modules/nomDuModule/src/").

Plutôt que la technique tordue du do{}while(0), il y celle-ci :

Code:

---

#define foo(X) ({ wat(X); X; })

---

Mais il me semble que celle-ci est une extension GNU.

Citation:

---

Envoyé par raphamil

Plutôt que la technique tordue du do{}while(0), il y celle-ci :

Code:

---

#define foo(X) ({ wat(X); X; })

---

---

Code:

---

1 2 3 4

if (test()) foo(X); else foo(Y);

---

kaboum :aie: non?

Sinon, ya cette technique là aussi

Code:

---

#define foo(X) wat(X), (X)

---

raphamil: oui mais non, parce que si tu ajoutes un ";" à la fin de ta macro, tu auras une erreur de syntaxe.

Code:

---

1 2 3

if(VarSetNum(Liste_at(l, 2)->val, 1, size_t) == 1) { printf("OK"); }

---

Code:

---

1 2 3 4 5 6 7

#define VarSetNum(This, n, type) ({ \   Var* _var_This_tmp = (This); \   VarFlush(_var_This_tmp); \   _var_This_tmp->p = malloc(sizeof(type)); \   _var_This_tmp->Delete = free; \   *(type*)_var_This_tmp->p = n; \ })

---

J'ai compilé en -std=c89, et ça marche.

Citation:

---

Mais il me semble que celle-ci est une extension GNU.

---

Edit: j'ai aussi essayé en -pedantic, j'ai quelques warnings. Pas glop ?

Mais si je remplace ({ ... }) par do{ ... } while(0), comment je fais la condition ?

Citation:

---

Envoyé par Gui13

raphamil: oui mais non, parce que si tu ajoutes un ";" à la fin de ta macro, tu auras une erreur de syntaxe.

---

Code:

---

VarSetNum(Liste_unshift(l, ListeElementnew())->val, i, size_t);

---

Ce code compile.

Citation:

---

Envoyé par Gruik

Code:

---

1 2 3 4

if (test()) foo(X); else foo(Y);

---

kaboum :aie: non?

Sinon, ya cette technique là aussi

Code:

---

#define foo(X) wat(X), (X)

---

---

Tu es sûr d'avoir des effets de bord avec ce genre de machin (qu'il faudrait mettre entre parenthèses d'ailleurs).

Citation:

---

Envoyé par raphamil

Mais si je remplace ({ ... }) par do{ ... } while(0), comment je fais la condition ?

---

Oui, avec la technique do while, on peut pas faire comme si la macro retournait quelquechose. Edit : et on peut pas non plus mettre la macro dans une condition de structure de controle, en effet.
Par contre avec la technique ({...}), quelle est la valeur de retour?

La valeur de la dernière instruction : regarde mon code.
Ah tiens sinon, un simple { } fait l'affaire à la place du do-while.
On entoure la macro entre parenthèses pour avoir la valeur du bloc et c'est bon :) .
(Je teste).

Citation:

---

Envoyé par raphamil

La valeur de la dernière instruction

---

Ok, c'est bon à savoir, faudrait verifier ce que dit la norme quand meme (le fait de mettre -std=c89 n'est pas forcement une preuve)

Citation:

---

Ah tiens sinon, un simple { } fait l'affaire à la place du do-while.
On entoure la macro entre parenthèses pour avoir la valeur du bloc et c'est bon .
(Je teste).

---

Essaye aussi

Code:

---

1 2 3 4

if (test()) foo(X); else foo(Y);

---

Code:

---

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

#include <stdio.h>   #define foo(X) { X; } #define foo2(X) ({ X; }) #define foo3(X) do{ X; }while(0)   int main(void) { if(1) { foo(getchar()); if(foo2(getchar()) == '1') {} foo3(getchar()); } else { foo(putchar('F')); foo2(putchar('F')); foo3(putchar('F')); } return 0; }

---

Avec

Citation:

---

gcc -std=c89 -pedantic -W -Wall -Wextra gnuc.c

---

j'ai

Citation:

---

gnuc.c: In function ‘main’:
gnuc.c:16: warning: ISO C forbids braced-groups within expressions
gnuc.c:20: warning: ISO C forbids braced-groups within expressions

---

Et on ne peut pas utiliser les deux autres dans une structure de contrôle.

Ok, je voulais juste signaler les problèmes qu'il pouvait y avoir en utilisant une macro qui définit "{ ... }"

Code:

---

1 2 3 4

if (test()) foo(X); else foo(X);

---

est remplacé par

Code:

---

1 2 3 4

if (test()) { X }; else { X };

---

Soit 2 instructions avec le point virgule, le else est en erreur.
Biensur, cela n'arrive que si on ne met pas de bloc d'accolades dans nos structures de controle, ce qu'on ne fait jamais lorsqu'on a une certaine experience mais bon, on devrait pouvoir utiliser la macro le plus possible comme une fonction classique...
Il y a un cas plus tordu avec des ifs imbriqués où il n'y a meme pas d'erreur, le problème est invisible (flemme de l'écrire).
Je disais que le do {} while(0) empeche tout ça, mais peut etre que la technique ({ }) aussi, c'est ce que je demandais de tester.
A priori ({ }); est considéré comme une seule instruction donc ça marcherait.


A part ça, j'ai regardé la norme, et d'après ce que je comprends, on ne peut mettre que des "expressions" dans les parenthèses, et non des "statements". Une "statement" n'est pas une "expression" apparemment, et un block d'accolades est une "statement". Donc il est pas possible de mettre des blocks d'accolades dans des parenthèses.

Donc oui on peut utiliser ({ }) si on ne compte pas faire du C standard. Le flag -pedantic le signale en effet, je pensais que mettre le flag -std=c89 aurait suffi.

Notez que ça ne marche pas sous Visual, donc autant directement mettre -std=gnuXX...

Pour finir, donc, la norme interdit-elle de définir une macro via une autre macro?

Comme celle que je voulais déclarer:

Code:

---

#define DEFTRACE(X) #define TRACE(Y) do{printf((X)); (Y);}while(0)

---

(le code ne compile pas avec ma version de GCC non C99)

Oui.

Par rapport aux multi-instructions :


Il me semble (souvenirs lointains) que la manière "standard" de faire des define multi-instructions était le '\' en fin de ligne (C89, 90, 95) (le do..while me semble d'usage assez récent).

Le backslash en fin de ligne ne change rien à cela, car c'est toujours le point-virgule (ou dans certains cas, la virgule) qui sépare les instructions.

Citation:

---

Envoyé par Médinoc

Le backslash en fin de ligne ne change rien à cela, car c'est toujours le point-virgule (ou dans certains cas, la virgule) qui sépare les instructions.

---

je n'ai pas dit le contraire, j'ai dit pour les MACROS multi-instructions...
:)

Citation:

---

Envoyé par souviron34

Es-tu sûr ?

Il me semble (souvenirs lointains) que la manière "standard" de faire des define multi-instructions était le '\' en fin de ligne (C89, 90, 95) (le do..while me semble d'usage assez récent).

---

Oui, je suis sur qu'on ne peut pas definir une macro definissant des macros.

L'utilisation de \ en fin de ligne permet de definir une macro sur plusieurs lignes.

L'utilisation de do {} while(0) permet de definir une macro comportant plusieurs instructions mais visible de l'exterieur comme une seule (suivant le nombre d'instructions, tu la coupes souvent en plusieurs lignes avec \). Cad qu'elle ne pose pas de problemes dans les contextes (if (cond) macro(); else) qui posent problemes
si tu utilises un bloc sans le savoir.

L'utilisation de l'operateur , permet de definir une macro qui est une expression et qui en evalue plusieurs (pas de if -- mais on a ?: -- ou autre structures de controle).

Aucune de ces techniques n'est recente (je suis sur des les avoir utilisees au debut des annees 90).

Merci bien :)

Je me suis tourné vers autre chose, du genre un système de traces sous forme de module (un couple .h / .c qui définit quelques fonctions de base pour tracer l'execution de mon programme, et une seule macro).