Después de leer la respuesta magistral de Chris Dodd y pasar un tiempo pensando, creo que he entendido el problema.

Si está utilizando el preprocesador C como una persona normal y cuerda , realmente no hay ningún problema que evitar aquí. Simplemente no hagas macros que se mencionen entre sí y estarás bien. Sin embargo, si está incursionando en las artes oscuras , encontrará que es sorprendentemente fácil tropezar con el problema anterior. Así que aquí, voy a explicar cómo evitarlo.

Tenga en cuenta que no voy a explicar por qué sucede esto aquí (la respuesta de Chris ya explica muy bien por qué), pero voy a exponer dónde suceden y cómo resolverlos .

El problema puede ocurrir cuando su macro "llamada" tiene una expansión pospuesta/indirecta . Lo que quiero decir con "indirecto" es una expansión que no se puede hacer en ese mismo momento, sino solo después de alguna concatenación o sustitución/reemplazo. Para entenderlo, veamos primero un ejemplo seguro:

 #define EXPAND(MACRO) MACRO #define MY_MACRO(A, B) A##B EXPAND(MY_MACRO(1,2)) // 12

Aquí, MY_MACRO(1,2) es una referencia inmediata a una macro y tiene los argumentos adecuados para expandirse tal cual. Por lo tanto, el preprocesador lo expandirá inmediatamente , antes de cualquier reemplazo en EXPAND .

Ahora vamos a compararlo con estos ejemplos:

 #define EXPAND(MACRO, PAREN_ARGS) MACRO PAREN_ARGS #define MY_MACRO(A, B) A##B EXPAND(MY_MACRO, (1,2)) // 12

 #define EXPAND(MACRO) MACRO (1,2) #define MY_MACRO(A, B) A##B EXPAND(MY_MACRO) // 12

Tenga en cuenta que los argumentos dentro de EXPAND (" MY_MACRO, (1,2) " y " MY_MACRO ") no "parecen una macro". Aunque queremos que se expandan por completo al final, no tienen el formato correcto para expandirse en ese mismo momento del argumento. Aunque estos funcionan bien ahora, debido a que no hay una referencia mutua, su expansión se pospondrá después del reemplazo en EXPAND , y eso puede plantear un problema.

Siempre que la macro en su argumento no se pueda expandir tal como está, no puede contener el "destinatario" en ningún punto de su expansión .

Podemos mostrar esto agregando una referencia mutua a los ejemplos anteriores:

 #define EXPAND(MACRO, PAREN_ARGS) MACRO PAREN_ARGS // Now MY_MACRO references EXPAND #define MY_MACRO(A, B) EXPAND(A,B) // Fails to expand EXPAND(MY_MACRO, (1,2)) // EXPAND(1,2) ^ ^ | | | This guy is postponed... | ...so it cannot eventually expand to this guy.

 #define EXPAND(MACRO) MACRO (1,2) // Now MY_MACRO references EXPAND #define MY_MACRO(A, B) EXPAND(A) // Fails to expand EXPAND(MY_MACRO) // EXPAND(1) ^ ^ | | | This guy is postponed... | ...so it cannot eventually expand to this guy.

Nuestro ejemplo sin la expansión indirecta por otro lado, es completamente seguro y se evalúa como se esperaba:

 #define EXPAND(MACRO) MACRO // Now MY_MACRO references EXPAND #define MY_MACRO(A, B) EXPAND(A) // Succeeds EXPAND(MY_MACRO(1,2)) // 1 ^ ^ | | | This guy can expand right here... | ...so it can freely expand to this guy.

Dado que MY_MACRO(1,2) es una macro real, se puede evaluar en ese mismo momento y no se producen problemas.

Si mi juicio es correcto, no tiene que preocuparse por ningún "llamado anterior", solo el que directamente tiene como argumento la "macro pospuesta". Tampoco tiene que preocuparse por los otros argumentos, ya que el preprecesor también intentará expandirlos por completo antes del reemplazo. Además, esto no supone ningún problema si no se requiere la expansión completa de la macro.

Sin embargo, si desea que la macro en su argumento se expanda por completo y su expansión será indirecta, verifíquelo dos veces.

La expansión de macros es un proceso complejo que en realidad solo es comprensible al comprender los pasos que ocurren.

1. Cuando se reconoce una macro con argumentos (token de nombre de macro seguido de ( token), los siguientes tokens hasta el correspondiente ) se escanean y dividen (on , tokens). No ocurre ninguna expansión de macro mientras esto sucede (por lo que , s y ) deben estar presentes en el flujo de entrada directamente y no pueden estar en otras macros).

2. Cada argumento de macro cuyo nombre aparece en el cuerpo de la macro no precedido por # o ## o seguido por ## es "preescaneado" para que las macros se expandan; cualquier macro que esté completamente dentro del argumento se expandirá recursivamente antes de sustituirla en el cuerpo de la macro.

3. Los flujos de token de argumento de macro resultantes se sustituyen en el cuerpo de la macro. Los argumentos involucrados en las operaciones # o ## se modifican (en cadena o se pegan) y se sustituyen en función de los tokens del analizador original del paso 1 (el paso 2 no ocurre para estos).

4. El flujo de token del cuerpo de la macro resultante se escanea nuevamente en busca de macros para expandir, pero ignorando la macro que se está expandiendo actualmente. En este punto, se pueden incluir más tokens en la entrada (después de lo que se escaneó y analizó en el paso 1) como parte de cualquier macro reconocida.

Lo importante es que hay DOS DIFERENTES expansiones recursivas que ocurren (paso 2 y paso 4 arriba) y SOLO la del paso 4 ignora las expansiones de macro recursivas de la misma macro. La expansión recursiva en el paso 2 NO ignora la macro actual, por lo que puede expandirla recursivamente.

Entonces, para su ejemplo anterior, veamos qué sucede. para la entrada

 EXPAND(TEST PARENTHESIS())

• el paso 1 ve la macro EXPAND y escanea en la lista de argumentos TEST PARENTHESIS() para X
• el paso 2 no reconoce TEST como una macro (sin seguir ( ), pero reconoce PARENTHESIS :
  • el paso 1 (anidado) obtiene una secuencia de token vacía para el argumento
  • el paso 2 escanea esa secuencia vacía y no hace nada
  • el paso 3 se inserta en el cuerpo de la macro () produciendo exactamente eso: ()
  • paso 4 escanea () en busca de macros y no encuentra ninguna
• por lo que el valor final de X después del paso 2 es TEST ()
• el paso 3 lo inserta en el cuerpo, dando TEST ()
• el paso 4 suprime EXPAND y escanea el resultado del paso 3 en busca de más macros, encontrando TEST
  • el paso 1 obtiene una secuencia vacía para el argumento
  • el paso 2 no hace nada
  • paso 3 sustituye en el cuerpo dando EXPAND(0)
  • el paso 4 recursivo expande eso, suprimiendo TEST . En este punto, tanto EXPAND como TEST están suprimidos (debido a que se encuentran en el paso 4 de expansión), por lo que no sucede nada.

Tu otro ejemplo EXPAND(TEST()) es diferente

• paso 1 EXPAND se reconoce como una macro, y TEST() se analiza como el argumento X
• paso 2, esta secuencia se analiza recursivamente. Tenga en cuenta que dado que este es el paso 2, EXPAND NO ESTÁ SUPRIMIDO
  • paso 1 TEST se reconoce como una macro con un argumento de secuencia vacío
  • paso 2: nada (sin macros en una secuencia de fichas vacía)
  • paso 3, sustituido en el cuerpo dando EXPAND(0)
  • paso 4, TEST se suprime y el resultado se expande recursivamente
    • paso 1, EXPAND se reconoce como una macro (recuerde, en este punto, solo TEST se suprime mediante la recursividad del paso 4; EXPAND está en la recursividad del paso 2, por lo que no se suprime) con 0 como argumento
    • paso 2, se escanea 0 y no le pasa nada
    • paso 3, sustituir en el cuerpo dando 0
    • paso 4, 0 se escanea nuevamente en busca de macros (y nuevamente no sucede nada)
• paso 3, el 0 se sustituye como argumento X en el cuerpo del primer EXPAND
• paso 4, 0 se escanea nuevamente en busca de macros (y nuevamente no sucede nada)

entonces el resultado final aquí es 0

A los efectos de esta situación, hay tres pasos relevantes en el reemplazo de macros:

1. Realice el reemplazo de macros en los argumentos.
2. Reemplace la macro con su definición, con parámetros reemplazados con argumentos.
3. Vuelva a escanear el resultado para un reemplazo adicional mientras suprime el nombre de la macro reemplazada.

En EXPAND(TEST PARENTHESIS()) :

• Paso 1, el reemplazo de macros se realiza en el argumento EXPAND , TEST PARENTHESIS() :
  • TEST no va seguido de paréntesis, por lo que no se interpreta como una invocación de macro.
  • PARENTHESIS() es una invocación de macro, por lo que se realizan los tres pasos: Los argumentos están vacíos, por lo que no hay procesamiento para ellos. Luego PARENTHESIS() se reemplaza por () . Luego () se vuelve a escanear y no se encuentran macros.
  • El paso 1 está hecho y tenemos EXPAND(TEST ()) . ( TEST () no se vuelve a escanear porque no fue el resultado de ningún reemplazo de macro).
• Paso 2, EXPAND(TEST ()) se reemplaza por TEST () .
• Paso 3, TEST () se vuelve a escanear mientras se suprime EXPAND :
  • Paso 1, los argumentos están vacíos, por lo que no hay procesamiento para ellos.
  • Paso 2, TEST () se reemplaza por EXPAND(0) .
  • Paso 3, se EXPAND(0) , pero se suprime EXPAND .

En EXPAND(TEST ()) :

• Paso 1, el reemplazo de macros se realiza en el argumento EXPAND :
  • Paso 1, los argumentos de TEST están vacíos, por lo que no hay procesamiento.
  • Paso 2, TEST () se reemplaza por EXPAND(0) .
  • Paso 3, este reemplazo se vuelve a escanear y EXPAND(0) se reemplaza por 0 .
• Paso 2, EXPAND(TEST ()) se ha convertido en EXPAND(0) y EXPAND(0) se reemplaza por 0 .
• El paso 3, 0 se vuelve a escanear en busca de más macros, pero no hay ninguna.

Los otros ejemplos en la pregunta siguen de manera similar. Se reduce a:

• En TEST PARENTHESIS() , la falta de paréntesis después de TEST da como resultado que no se expanda mientras se procesan argumentos para una invocación de macro adjunta.
• Los paréntesis se colocan después cuando se expande PARENTHESIS , pero esto es después de escanear TEST y no se vuelve a escanear durante el procesamiento del argumento.
• Después de reemplazar la macro adjunta, se vuelve a escanear TEST y luego se reemplaza, pero, en este momento, se suprime el nombre de la macro adjunta.