Discussion :

[Gui13]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Que j'utiliserais ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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!

[rilou]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Gruik]

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

[Gui13]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Affiche dans la console:

[Mon Module] Mon Log

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

?

[Gruik]

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)

[Gui13]

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/").

[raphamil]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Médinoc]

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

[Gruik]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
if (test())
    foo(X);
else
    foo(Y);

kaboum non?

Sinon, ya cette technique là aussi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Gui13]

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

[raphamil]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

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 ?

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Ce code compile.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
if (test())
    foo(X);
else
    foo(Y);

kaboum non?

Sinon, ya cette technique là aussi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#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).

[Gruik]

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?

[raphamil]

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).

[Gruik]

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)

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
if (test())
    foo(X);
else
    foo(Y);

[raphamil]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

j'ai

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.

[Gruik]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
if (test())
    foo(X);
else
    foo(X);

est remplacé par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Médinoc]

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

[Gui13]

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

Comme celle que je voulais déclarer:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

[Jean-Marc.Bourguet]

Oui.

[souviron34]

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).