Uso en el mundo real de X-Macros

Acabo de enterarme de X-Macros . ¿Qué usos de X-Macros en el mundo real has visto? ¿Cuándo son la herramienta adecuada para el trabajo?

Jul 09 '11 22:07 Agnius Vasiliauskas

Las X-Macros son esencialmente plantillas parametrizadas. Por lo tanto, son la herramienta adecuada para el trabajo si necesita varias cosas similares en varias formas. Le permiten crear una forma abstracta y crear una instancia de ella según diferentes reglas.

Utilizo X-macros para generar valores de enumeración como cadenas. Y desde que lo encontré, prefiero esta forma que requiere una macro de "usuario" para aplicar a cada elemento. Es mucho más doloroso trabajar con la inclusión de múltiples archivos.

/* x-macro constructors for error and type
   enums and string tables */
#define AS_BARE(a) a ,
#define AS_STR(a) #a ,

#define ERRORS(_) \
    _(noerror) \
    _(dictfull) _(dictstackoverflow) _(dictstackunderflow) \
    _(execstackoverflow) _(execstackunderflow) _(limitcheck) \
    _(VMerror)
enum err { ERRORS(AS_BARE) };
char *errorname[] = { ERRORS(AS_STR) };
/* puts(errorname[(enum err)limitcheck]); */

También los estoy usando para el envío de funciones según el tipo de objeto. Nuevamente secuestrando la misma macro que usé para crear los valores de enumeración.

#define TYPES(_) \
    _(invalid) \
    _(null) \
    _(mark) \
    _(integer) \
    _(real) \
    _(array) \
    _(dict) \
    _(save) \
    _(name) \
    _(string) \
/*enddef TYPES */

#define AS_TYPE(_) _ ## type ,
enum { TYPES(AS_TYPE) };

El uso de la macro garantiza que todos los índices de mi matriz coincidirán con los valores de enumeración asociados, porque construyen sus diversas formas utilizando los tokens básicos de la definición de la macro (la macro TIPOS).

typedef void evalfunc(context *ctx);

void evalquit(context *ctx) { ++ctx->quit; }

void evalpop(context *ctx) { (void)pop(ctx->lo, adrent(ctx->lo, OS)); }

void evalpush(context *ctx) {
    push(ctx->lo, adrent(ctx->lo, OS),
            pop(ctx->lo, adrent(ctx->lo, ES)));
}

evalfunc *evalinvalid = evalquit;
evalfunc *evalmark = evalpop;
evalfunc *evalnull = evalpop;
evalfunc *evalinteger = evalpush;
evalfunc *evalreal = evalpush;
evalfunc *evalsave = evalpush;
evalfunc *evaldict = evalpush;
evalfunc *evalstring = evalpush;
evalfunc *evalname = evalpush;

evalfunc *evaltype[stringtype/*last type in enum*/+1];
#define AS_EVALINIT(_) evaltype[_ ## type] = eval ## _ ;
void initevaltype(void) {
    TYPES(AS_EVALINIT)
}

void eval(context *ctx) {
    unsigned ades = adrent(ctx->lo, ES);
    object t = top(ctx->lo, ades, 0);
    if ( isx(t) ) /* if executable */
        evaltype[type(t)](ctx);  /* <--- the payoff is this line here! */
    else
        evalpush(ctx);
}

El uso de X-macros de esta manera ayuda al compilador a mostrar mensajes de error útiles. Omití la función evalarray de lo anterior porque distraería mi punto. Pero si intenta compilar el código anterior (comentando las otras llamadas a funciones y proporcionando una definición de tipo ficticia para el contexto, por supuesto), el compilador se quejará de que falta una función. Para cada nuevo tipo que agrego, se me recuerda que debo agregar un controlador cuando vuelvo a compilar este módulo. Por lo tanto, la X-macro ayuda a garantizar que las estructuras paralelas permanezcan intactas incluso a medida que crece el proyecto.

Editar:

Esta respuesta ha elevado mi reputación en un 50%. Así que aquí hay un poco más. El siguiente es un ejemplo negativo , respondiendo a la pregunta: ¿ cuándo no utilizar X-Macros?

Este ejemplo muestra el empaquetado de fragmentos de código arbitrarios en el "registro" X. Finalmente abandoné esta rama del proyecto y no utilicé esta estrategia en diseños posteriores (y no por falta de intentarlo). De alguna manera se volvió incómodo. Efectivamente la macro se llama X6 porque en un momento hubo 6 argumentos, pero me cansé de cambiar el nombre de la macro.

/* Object types */
/* "'X'" macros for Object type definitions, declarations and initializers */
// a                      b            c              d
// enum,                  string,      union member,  printf d
#define OBJECT_TYPES \
X6(    nulltype,        "null",     int dummy      ,            ("<null>")) \
X6(    marktype,        "mark",     int dummy2      ,           ("<mark>")) \
X6( integertype,     "integer",     int  i,     ("%d",o.i)) \
X6( booleantype,     "boolean",     bool b,     (o.b?"true":"false")) \
X6(    realtype,        "real",     float f,        ("%f",o.f)) \
X6(    nametype,        "name",     int  n,     ("%s%s", \
        (o.flags & Fxflag)?"":"/", names[o.n])) \
X6(  stringtype,      "string",     char *s,        ("%s",o.s)) \
X6(    filetype,        "file",     FILE *file,     ("<file %p>",(void *)o.file)) \
X6(   arraytype,       "array",     Object *a,      ("<array %u>",o.length)) \
X6(    dicttype,        "dict",     struct s_pair *d, ("<dict %u>",o.length)) \
X6(operatortype,    "operator",     void (*o)(),    ("<op>")) \

#define X6(a, b, c, d) #a,
char *typestring[] = { OBJECT_TYPES };
#undef X6

// the Object type
//forward reference so s_object can contain s_objects
typedef struct s_object Object;

// the s_object structure:
// a bit convoluted, but it boils down to four members:
// type, flags, length, and payload (union of type-specific data)
// the first named union member is integer, so a simple literal object
// can be created on the fly:
// Object o = {integertype,0,0,4028}; //create an int object, value: 4028
// Object nl = {nulltype,0,0,0};
struct s_object {
#define X6(a, b, c, d) a,
    enum e_type { OBJECT_TYPES } type;
#undef X6
unsigned int flags;
#define Fread  1
#define Fwrite 2
#define Fexec  4
#define Fxflag 8
size_t length; //for lint, was: unsigned int
#define X6(a, b, c, d) c;
    union { OBJECT_TYPES };
#undef X6
};

Un gran problema fueron las cadenas en formato printf. Si bien se ve genial, es solo un truco. Dado que solo se usa en una función, el uso excesivo de la macro en realidad separó información que debería estar junta; y hace que la función sea ilegible por sí misma. La ofuscación es doblemente desafortunada en una función de depuración como ésta.

//print the object using the type's format specifier from the macro
//used by O_equal (ps: =) and O_equalequal (ps: ==)
void printobject(Object o) {
    switch (o.type) {
#define X6(a, b, c, d) \
        case a: printf d; break;
OBJECT_TYPES
#undef X6
    }
}

Así que no te dejes llevar. Como yo lo hice.

Jul 09 '2011 18:07 luser droog

Algunos usos reales de X-Macros en proyectos grandes y populares:

Punto de acceso Java

En la máquina virtual Oracle HotSpot para el lenguaje de programación Java®, existe el archivo globals.hpp, que utiliza RUNTIME_FLAGSde esa manera.

Ver el código fuente:

• JDK 7
• JDK 8
• JDK 9

Cromo

La lista de errores de red en net_error_list.h es una lista muy, muy larga de expansiones de macros de esta forma:

NET_ERROR(IO_PENDING, -1)

Lo utiliza net_errors.h desde el mismo directorio:

enum Error {
  OK = 0,

#define NET_ERROR(label, value) ERR_ ## label = value,
#include "net/base/net_error_list.h"
#undef NET_ERROR
};

El resultado de esta magia del preprocesador es:

enum Error {
  OK = 0,
  ERR_IO_PENDING = -1,
};

Lo que no me gusta de este uso en particular es que el nombre de la constante se crea dinámicamente agregando el archivo ERR_. En este ejemplo, NET_ERROR(IO_PENDING, -100)define la constante ERR_IO_PENDING.

Usando una simple búsqueda de texto ERR_IO_PENDING, no es posible ver dónde se definió esta constante. En cambio, para encontrar la definición, hay que buscar IO_PENDING. Esto hace que el código sea difícil de navegar y, por lo tanto, aumenta la ofuscación de toda la base del código.

Jul 09 '2011 16:07 Roland Illig

Me gusta usar macros X para crear 'enumeraciones ricas' que admitan la iteración de los valores de enumeración, así como la obtención de la representación de cadena para cada valor de enumeración:

#define MOUSE_BUTTONS \
X(LeftButton, 1)   \
X(MiddleButton, 2) \
X(RightButton, 4)

struct MouseButton {
  enum Value {
    None = 0
#define X(name, value) ,name = value
MOUSE_BUTTONS
#undef X
  };

  static const int *values() {
    static const int a[] = {
      None,
#define X(name, value) name,
    MOUSE_BUTTONS
#undef X
      -1
    };
    return a;
  }

  static const char *valueAsString( Value v ) {
#define X(name, value) static const char str_##name[] = #name;
MOUSE_BUTTONS
#undef X
    switch ( v ) {
      case None: return "None";
#define X(name, value) case name: return str_##name;
MOUSE_BUTTONS
#undef X
    }
    return 0;
  }
};

Esto no sólo define una MouseButton::Valueenumeración, sino que también me permite hacer cosas como

// Print names of all supported mouse buttons
for ( const int *mb = MouseButton::values(); *mb != -1; ++mb ) {
    std::cout << MouseButton::valueAsString( (MouseButton::Value)*mb ) << "\n";
}

Feb 20 '2015 09:02 Frerich Raabe