Präprozessor: Ausgabe Makroberechnung

[David B. (dave10)]

Hallo,


ich weis wie man ein Makro in einen String umwandelt mit:

#define STR_HELPER(x) #x
#define STR(x) STR_HELPER(x)

Aber wie kann ich eine Ausgabe realisieren, die mir ohne das Programm 
auf den µC zu programmieren oder zu Simulieren, eine Ausgabe zu 
realisieren.

Also ich habe z.B.

#define A 10
#define B 2.345
#define MAKRO_C ((int)((double)A*(double)B) + 0.5)

Ich weis, dass dies 23,45 sind: MAKRO_C ist also 23.

Ich habe aber viele kompliziertere Makros und würde gern kontrollieren, 
ob der Präprozessor, diese richtig berechnet.

Kann man irgendeine Ausgabe realisieren, ähnlich wie bei #warning.

Vielen Dank
David

[Mark B. (markbrandis)]

Kann man doch zur Laufzeit ausgeben lassen?

[David B. (dave10)]

Ja, ich weiß, dass habe ich ja auch schon gemacht, aber man muss dann 
alle Makros die man sehen will ausgeben lassen und den µC programmieren.

Ich wollte mir gern den Schritt des programmierens ersparen.

VG David

[Peter D. (peda)]

Der Präprozessor rechnet nichts aus, sondern der Compiler rechnet 
Konstanten aus. Du kannst Sie Dir dann im Assemblerlisting ansehen.

[(prx) A. K. (prx)]

David B. schrieb:
> Ich habe aber viele kompliziertere Makros und würde gern kontrollieren,
> ob der Präprozessor, diese richtig berechnet.

Der Präprozessor rechnet nur an exakt einer Stelle: in der Bedingung vom 
#if. Nirgends sonst. Alles andere ist reine Textersetzung.

Rechnungen lassen sich also per #if kontrollieren:
 #if SCHLUNZ != 42
   #error Unsinn
 #endif
aber blöderweise rechnet der Präprotz da nicht nach den exakt gleichen 
Regeln wie der Compiler. So mag er keine Fliesskommarechnung. Er 
interessiert sich auch nicht für Datentypen, was in
 #define N (1000000*1000000)
 #if N==1000000000000
   printf("%Ld\n", (long long)N);
 #endif
zum Ausgabe von -727379968 führen kann.

[David B. (dave10)]

Vielen Dank für die Erläuterung.

VG David

[Oliver (Gast)]

Es gibt für jeden Compiler eine Option, mit der er den 
Preprozessoroutput anzeigt. Beim gcc wäre das -E, wie das bei anderen 
geht, steht in der Doku.

Aber wie schon gesagt wurde, der Preprozessor rechnet nicht.

Oliver

[Wolfgang H. (frickelkram)]

Hallo David,
keine Ahnung welchen Compiler Du benutzt, aber bei gcc hilf die Option 
-save-temps . Als Ergebnis des Compiler Durchlaufs beleibt eine Datei 
mit der Endung .i zurück. Darin kannst Du die Ersetzung der Makros 
sehen.
Mit der Programmierung des Prozessors hat das nichts zu tun. Wenn Du ein 
Makefile verwendest ist da normalerweise das Compilieren vom Brennen des 
µ-Prozessors getrennt.
Wie Peter schon geschrieben hat rechnet der Präprozessor nicht. Wenn Du 
Dir die Ausgabe des Präprozessors ansiehst kannst Du das gut 
nachvollziehen.
Bei vielen, komplizieren Makros frage ich mich persönlich beim 
Programmieren immer ob ich gerade nicht doch auf dem Holzweg bin und mit 
den Makros Dinge mache, die ich besser mit z.B. Funktionen machen 
sollte.

[(prx) A. K. (prx)]

Wolfgang Heinemann schrieb:
> Bei vielen, komplizieren Makros frage ich mich persönlich beim
> Programmieren immer ob ich gerade nicht doch auf dem Holzweg bin und mit
> den Makros Dinge mache, die ich besser mit z.B. Funktionen machen
> sollte.

Was mit Funktionen gut machbar ist, das macht man besser damit.

[David B. (dave10)]

die Option -save-temps ist wirklich eine schöne Sache.
Vielen Dank für den Hinweis.