Mantenga un registro de la expansión macro

Question

Quiero realizar un seguimiento de la expansión macro: cuántas veces se ha ampliado la macro y cuáles son los args cuando ocurrió la expansión.

por ejemplo,

Tengo una macro que podría parecer esto:

#define mymacro(x) int x

y en mi código tengo algo como esto:

mymacro(a);
mymacro(b);

Al final de la expansión del preprocesador (oh, sí, ¿hay una manera de hacer una macro específica para convertirse en el último para expandirse?), Me gustaría saber cuántas veces se ha usado Mymacro y qué pasan los args..En este caso, sería 2 veces, y Args sería A y B.

Estaba investigando Boost-preprocesador lib.Tienen boost_pp_array, pero no sé cómo hacerlo "estático", para que pueda usarlo más tarde.

Encontré algo en el BOOST_PP_COUNTER.Parece que el boost_pp_counter es algo que puede mantener su estado en la frase de preprocesadores.Pero todavía no estoy claro cómo hacer lo que quería.

Answer 1

How about something like this?

#include <iostream>

int m_counter = 0;
const char *m_arguments[32] = { 0 };

#define COUNT_M(a) m_arguments[m_counter++] = #a;
#define M(a) COUNT_M(a) int a

int main()
{
    M(x);
    M(y);

    for (int i = 0; i < m_counter; i++)
    {
        std::cout << "m_arguments[" << i << "] = \"" << m_arguments[i] << "\"\n";
    }
}

Answer 2

I'm not quite sure what your ultimate goal is, but you can track the number of scans(not the number of expansions) using an active argument. An active argument expands each time that it is scanned by the preprocessor. For example,

#define EMPTY()

#define A(n) \
    A_INDIRECT EMPTY()()(BOOST_PP_INC(n)) 

#define A_INDIRECT() A

#define X(arg) arg
#define Y(arg) X(arg)
#define Z(arg) Y(arg)

   A(0)   // A_INDIRECT()(1)
X( A(0) ) // A_INDIRECT()(2)
Y( A(0) ) // A_INDIRECT()(3)
Z( A(0) ) // A_INDIRECT()(4)

Each invocation of A is subjected to a different number of scans, which causes the results to be different each time.

Macros can't effect the global state. The only other way to achieve some sort of state is to use recursion. Remember, macros don't expand recursively, so the preprocessor keeps tracks of this state. Its the only "global" state that can be affected by macros. However, it can be difficult to control. Macros have to be forced to expand at a certain recursion level with a macro for each level, and some form of binary searching is required to read the "state" efficiently.