Come posso ottenere il preprocessore gcc per verificare se un'espressione valuta un valore o nulla?

Question

Sto utilizzando gcc (in particolare avr-gcc).

Quindi questo è il mio dilemma:

Diciamo che ho questi definita da qualche parte:

#define THING_0_A 0 
#define THING_0_B 1 
#define THING_1_A 0 

Poi, in un secondo file ho questo:

#define CONCAT_(A,B,C) A ## B ## C 
#define CONCAT(A,B,C) CONCAT_(A,B,C) 

#define ID 0 

#define THING_N(A) CONCAT(THING_,ID,A) 

Con questo ora ho una selezione di espressioni (sempre nel secondo file):

THING_N(_A) // evaluates to 0 
THING_N(_B) // evaluates to 1 
THING_N(_C) // evaluates to... nothing? Or undefined? Or THING_0_C? 

Ora, quello che sto cercando di capire è come fare questo (anche ancora nel secondo file):

#ifdef THING_N(_A) 
    // Do something knowing that THING_N(_A) is defined (in this case THING_0_A) 
#endif 

Oppure:

#if THING_N(_A) 
    // Do something knowing that the value THING_N(_A) evaluates to is defined and not just "nothing" 
#endif 

Naturalmente nessuno di questi lavori, perché #ifdef non può prendere un'espressione come argomento (e comunque finirebbe come "#ifdef 0"), e THING_N (_A) restituisce 0 all'interno di #if.

In altre parole, sto cercando un modo per rendere il preprocessore valutare:

THING_N(_A) to true 
THING_N(_B) to true 
THING_N(_C) to false 
THING_N(_D) to false 
etc... 

per essere utilizzato in un condizionale.

Answer 1

Così, dopo aver fatto un po 'di ricerca e di sperimentazione I' Ho concluso che non c'è una soluzione alla mia domanda, e la ragione di ciò è in realtà abbastanza semplice.

Data la configurazione che ho nella mia domanda a questo è ciò che le espressioni vengono valutate per:

THING_N(_A) -> THING_0_A -> 0 
THING_N(_B) -> THING_0_B -> 1 
THING_N(_C) -> THING_0_C -> 0 (Not nothing, as I previously thought.) 

Il pezzo di informazioni che mi mancava in precedenza era che, secondo la norma C99, identificatori non definiti verranno convertiti in 0, non nulla, rendendo impossibile distinguere tra qualcosa di indefinito e qualcosa definito come 0.

Se lo standard c99 scelto per rendere gli identificatori non definiti non valesse nulla, proprio come lo #define FOO fa in modo che FOO non valuti nulla, allora la soluzione di atturri avrebbe funzionato.

Oh bene.

Answer 2

Prova questo:

#if (1-THING_N(_A)-1 != 2) 

Questo sarà true per ogni valore di THING_N(_A) (tranne che per il valore -2). Sarà false solo se THING_N(_A) non è definito o è definito vuoto.

Se c'è una possibilità che la macro può espandersi a -2, è possibile modificare la seconda 1 e gli altri 2 a letterali di vostra scelta in modo che l'idea di base detiene.

Answer 3

È possibile concatenare il valore con un valore noto, e controllare il risultato:

#define EMPTY_VAL_HELPER(VAL) VAL ## 1 
#define EMPTY_VAL(VAL)   EMPTY_VAL_HELPER(VAL) 

Ora si potrebbe fare:

#if defined(FOO) && (EMPTY_VAL(FOO) == 1) 
//FOO is defined, but empty 
#endif 

#if defined(FOO) && (EMPTY_VAL(FOO) != 1) 
//FOO is defined, and not empty 
#endif