C Preprozessor-Trickserei

[Moriz (untertaucher)]

Mit dem C Preprozessor kann man Symbole generieren, in deren Namen die 
Zeilennummer steckt, an der sie erzeugt wurden:

#define CAT(x, y)  x ## y
#define CAT2(x, y) CAT(x, y)
#define VARIABLE   CAT2(variable, __LINE__)

int VARIABLE;      // erzeugt variable5

So weit so schön. Aber kann man das noch weiter treiben?
Ich hätte gerne ein Macro, das in einem Header ganz oben im Quellfile 
definiert ist und in der Expansion ein Symbol einsetzt, das zur 
Definitionszeit des Macros noch gar nicht existiert:

// Header
#define SPEZIAL()    spezial(<MODULE_ID>, <__LINE__>)

// Ende des Headers

#define MODULE_ID    13

SPEZIAL()            // soll expandieren zu spezial(13, 8)

Geht sowas überhaupt und wenn ja, wie bekommt man es hin?

[Moriz (untertaucher)]

Ich habs rausgefunden:

#define CAT(x, y) x, y
#define CAT2(x, y) CAT(x, y)
#define SPEZIAL()         spezial(CAT2(MODULE_ID, __LINE__))

#define MODULE_ID         51

SPEZIAL()                 // expandiert zu spezial(51, 7)

[Christian M. (likeme)]

我不明白

[Thorsten S. (thosch)]

Christian M. schrieb:
> 我不明白

很搞笑

[Random .. (thorstendb)]

Der Klassiker ist

__FILE__, __LINE__

[Daniel A. (daniel-a)]

Vielleicht kannst du statt einer Modul ID einfach das `static` keyword 
nehmen? Und schau dir eventuell auch mal `__attribute__((constructor))` 
an. Für innerhalb von Funktionen, schau dir scope blöcke und compound 
literale an. `{ int x; }`, `(int){123}`.

Wenn man die geschickt einsetzt, braucht man meistens gar keine Hacks 
mit solchen magischen Modulnummern mehr, und oft kann man auch ohne 
`__LINE__` auskommen.

[Moriz (untertaucher)]

Daniel A. schrieb:
> Vielleicht kannst du statt einer Modul ID einfach das `static` keyword
> nehmen?

Ich habe nicht geschrieben, wofür ich das brauche… Das hole ich jetzt 
nach:

Mein Programmpaket enthält einen Header namens config.h, der in alle 
Module an erster Stelle nach den Library-Includes includet wird. Dort 
stehen die grundlegenden Generierungsparameter drin und unter anderem 
auch die Modul-IDs für jeden .c-File und die Fehlernummern, die in dem 
jeweiligen Modul vorkommen. (Die ModulID und Fehlernummer kann bei 
fatalen Fehlern mit einer LED signalisiert werden und anhand der Nummern 
findet man mittels config.h sehr schnell die Stelle, an der es gerumst 
hat.)

In jedem .c-Modul steht nach den includes ein
   #define MODULE_ID MODULE_MAIN_C
oder wie der Modul auch immer heißt. (In config.h ist MODULE_MAIN_C als 
Zahlwert definiert.)

So weit das Vorgeplänkel, das den Trick mit dem cpp lohnend macht. Nun 
zum aktuellen Problem: ich will den Watchdog so integrieren, dass er dem 
Programm mit einem Reset wieder auf die Beine hilft, wenn es sich 
irgenwo verlaufen hat.

Dummerweise hatte ich in etlichen Modulen und teilweise ganz tief in den 
Hardware-Dingen wdt_rest() Aufrufe eingebaut. Als ich nun die wdt_reset 
an kritischen Stellen im Programm testweise lahmlegte, hätte der WD 
einen Reset machen sollen – hat er aber nicht, weil eben irgendwo noch 
andere wdt_reset-Aufrufe waren…

Was tun?

Ich habe in die config.h folgendes Fragment eingefügt:

    #ifndef ALLOW_WDT_ACCESS
        #undef wdt_reset
        void __wdt_reset(uint8_t moduleID, uint16_t line);

        #define WDT_CAT(x, y)       x, y
        #define WDT_CAT2(x, y)      WDT_CAT(x, y)

        #define wdt_reset()         __wdt_reset(WDT_CAT2(MODULE_ID, __LINE__))
    #endif // ALLOW_WDT_ACCESS

Nur in watchdog.c ist ALLOW_WDT_ACCESS definiert – damit kann nur der 
ein echtes wdt_reset ausführen.

Alle andern Module expandieren statt dem üblichen wdt_reset aus 
avr/wdt.h zu

__wdt_reset(MODULE_ID, __LINE__)

Die Funktion, die statt des Macros aufgerufen wird sieht so aus:

void __wdt_reset(uint8_t moduleID, uint16_t line) {
    uart_puts_P(PSTR("wdt_reset: "));
    uintOut(moduleID);
    uart_putchar(',');
    uintOut(line);
    nl();

    wdt_reset();
}

Weil sie in watchdog.c liegt, wird dort wdt_reset aus avr/wdt.h 
ausgeführt.

Damit ist mit geringsten Eingriffen eine Trace-Funktion für wdt_reset 
implementiert, die sich natürlich mit noch weniger Handgriffen wieder 
deaktivieren lässt…

[Moriz (untertaucher)]

Christian M. schrieb:
> 我不明白
无所谓

[Bauform B. (bauformb)]

Random .. schrieb:
> Der Klassiker ist__FILE__, __LINE__

https://stackoverflow.com/questions/4384765/whats-the-difference-between-pretty-function-function-func

[Moriz (untertaucher)]

_FUNCTION_ und Consorten sind für kleine Microcontroller eher 
ungeeignet.

[Bauform B. (bauformb)]

Aber _func_ auch? Wenn der TO sowieso Text ausgibt?

[Moriz (untertaucher)]

Ja auch. Überleg dir einfach mal, wie oft der Text in meinem Code 
vorkommt und wie oft _func_ bei einer an vielen Stellen aufgerufenen 
Funktion im Maschinencode vorkäme.

Auf "richtigen" Rechnern kann man sowas machen, auf einem 328, der nicht 
mehr so viel Platz im Flash hat, eher nicht.

[Bruno V. (bruno_v)]

Moriz schrieb:
> Damit ist mit geringsten Eingriffen eine Trace-Funktion für wdt_reset
> implementiert,

Wenn ich das richtig sehe, brauchst Du keine Makroexpansion dazwischen.

Wenn Du eine echte Funktion aufrufst, werden Makros von allein ersetzt.

 #define wdt_reset() __wdt_reset(MODULE_ID, __LINE__)

sollte reichen. CAT2 & Co brauchst Du nur für Function-Like-Makros mit 
Parametern.

[Moriz (untertaucher)]

Bruno V. schrieb:
> Wenn ich das richtig sehe, brauchst Du keine Makroexpansion dazwischen.

Du hast Recht.

Damit vereinfacht sich das Fragment für config.h:

    #ifndef ALLOW_WDT_ACCESS
        #undef wdt_reset
        void __wdt_reset(uint8_t moduleID, uint16_t line);

        #define wdt_reset()         __wdt_reset(MODULE_ID, __LINE__)
    #endif // ALLOW_WDT_ACCESS

[Peter D. (peda)]

Macros und kaskadierte Macros werden immer erst an der Stelle des 
Aufrufs expandiert.
Die Zeile und die Reihenfolge der Definitionen spielt keine Rolle.
Eine Ausnahme bildet #undef, das ist genau ab dieser Zeile gültig.

[Yalu X. (yalu) (Moderator)]

Peter D. schrieb:
> Eine Ausnahme bildet #undef, das ist genau ab dieser Zeile gültig.

Das ist aber keine Ausnahme, auch ein #define ist erst ab der Zeile 
gültig, in der es steht.