c(++) macro in #define expandieren

[Vlad T. (vlad_tepesch)]

Hi gibt es eine Möglichkeit, ein Makro definieren, was in ein Define 
expandiert?

also:

#define DECLARE_PARAM(type, name, value)  \
#define name ((type)(value))

DECLARE_PARAM(  uint32_t,  SUB_PARAM,  0xBAD )

benötigt wird das, da möglichst komfortabel je nach Umgebung entweder 
eine Präprozessor-Konstante oder eine Konfigurations-Variable hinterlegt 
werden soll.

der andere Fall ist einfach, nur dies hier mach mir Kopfschmerzen.

Danke,
Vlad

[Vlad T. (vlad_tepesch)]

das grundsätzlich eProblem, ist, dass der expandierte Code nicht mehr 
präprozessiert wird - aber warum? wenn ich normalerweise eine 
Präprozessorkonstannte durch eine andere expandiere funktioniet es doch 
auch.

warum funktioniert

#define TEST_B   5
#define TEST_A   TEST_B

aber nicht

#define HASH #
#define fHASH(x) x
#define DECLARE_PARAM(type, name, default) \
fHASH(HASH)define name ((type)default)

[Rolf Magnus (Gast)]

Nein, sowas geht nicht. Der Präprozessor parst das ja auch nicht 
mehrmals. Er würde also ein erzeugtes #define sowieso nie sehen.

[Vlad T. (vlad_tepesch)]

Rolf Magnus schrieb:
> Nein, sowas geht nicht. Der Präprozessor parst das ja auch nicht
> mehrmals.
Naja irgendwie schon - siehe beispiel

> Er würde also ein erzeugtes #define sowieso nie sehen.
prinzipiell könnte es auch mit nur einem Durchlauf gehen, wenn er bei 
der Ersetzung vor dem Ersetzten Text stehen bleibt und dann weiterläuft

[Rolf Magnus (Gast)]

Das stimmt schon. Aber im einen Fall muß er nur einen Text durch einen
anderen ersetzen. Im anderen müßte er diesen anderen Text wieder als 
eigenes Kommando evaluieren, da ja das "#define" selbst Ergebnis der 
Ersetzung ist. Völlig unmöglich wäre das sicher nicht, aber der 
Präprozessor macht es halt nicht.
Ich denke nicht, daß dir viel anderes übrig bleibt, als nochmal einen 
Makroprozessor wie m4 davorzusetzen oder den Code über die Skriptsprache 
deiner Wahl zu generieren.

[Karl H. (kbuchegg)]

Was gehen könnte:

Es gibt ja bei den meisten Compilern die Möglichkeit das Ergebnis nach 
dem Präprozessorlauf abzufangen ohne danach den eigentlichen Compiler 
aufzurufen.

Du müsstest dir praktisch vom Compiler den Präprozessor 'ausborgen', 
deinen Code da einmal durchlaufen lassen, das Ergebnis abfangen und dann 
dieses Zwischenergebnis nochmal durch den Compiler (und damit durch den 
Präprozessor) schicken.

Könnte klappen.

[Vlad T. (vlad_tepesch)]

Rolf Magnus schrieb:
> Ich denke nicht, daß dir viel anderes übrig bleibt, als nochmal einen
> Makroprozessor wie m4 davorzusetzen

Karl Heinz Buchegger schrieb:
> Es gibt ja bei den meisten Compilern die Möglichkeit das Ergebnis nach
> dem Präprozessorlauf abzufangen ohne danach den eigentlichen Compiler
> aufzurufen.


Ja mit zusätzlichen Build-Schritten wär das kein großes Problem, das 
wollte ich halt nur vermeiden. scheint aber unmöglich zu sein.

Trotzdem Danke für eure Vorschläge

[sebastian (Gast)]

Warum muss es unbedingt eine Präprozessor-Konstante sein?
Deklarier dir doch einfach eine Variable mit "static const" und hoffe, 
dass der compiler das zum gleichen Code optimiert. "static" damit er 
weiss, dass es in keiner anderen Übersetzungseinheit gebraucht wird.