c(++) macro in #define expandieren

#2507382
Lesenswert?

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

also:
1
#define DECLARE_PARAM(type, name, value)  \
2
#define name ((type)(value))
3

4
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
#2507390
Lesenswert?

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
1
#define TEST_B   5
2
#define TEST_A   TEST_B
aber nicht
1
#define HASH #
2
#define fHASH(x) x
3
#define DECLARE_PARAM(type, name, default) \
4
fHASH(HASH)define name ((type)default)
#2507394
Lesenswert?

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
Gast #2507404
Lesenswert?

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.
#2507435
Lesenswert?

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.
#2507754
Lesenswert?

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

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren