Создание связанного x-макроса из существующего

Рассмотрим следующий пользовательский стиль x-macro:

#define PRIMES_X(func) \
  func(2) \
  func(3) \
  func(5) \
  func(7)

Мы можем использовать это для расширения переданного макроса func неоднократно с первыми четырьмя простыми числами. Например:

#define MAKE_FUNC(num) void foo ## num();
PRIMES_X(MAKE_FUNC)

Объявил бы функции, возвращающие пустоту foo2(), foo3(), foo5() а также foo7(),

Все идет нормально.

Допустим, я знаю, хочу создать связанный x-макрос, который вызывает свой аргумент не с голыми простыми числами 2, 3,... но с некоторым токеном, полученным из него, таким как имена функций выше. То есть я хочу это:

#define PRIMES_FOO_X(func) \
  func(foo2) \
  func(foo3) \
  func(foo5) \
  func(foo7)

но на самом деле не выписывая все это (на самом деле, это было бы не синхронизировано момент PRIMES_X изменения.

То, что я хочу, это способ определения PRIMES_FOO_X с точки зрения PRIMES_X, Я почти могу добраться, например:

#define FOO_ADAPT(num) func(foo ## num)
#define PRIMES_FOO_X(f) PRIMES_X(FOO_ADAPT)

В этом случае, PRIMES_FOO_X расширяется до:

  func(foo2) \
  func(foo3) \
  func(foo5) \
  func(foo7)

... который выглядит правильно, но func здесь не переданный аргумент, а просто символ func поскольку FOO_ADAPT не имеет аргумента под названием func, только PRIMES_FOO_X(func) делает (и не использует его).

Я не могу найти способ сделать эту работу.

Источник

4 ответа

Возможно, достаточно простого обходного пути.

Вместо того, чтобы передавать аргумент func в PRIMES_FOO_XВы можете объявить это заранее. Например, в этом коде мы используем FOO_FUNC держать func:

#define PRIMES_FOO_X PRIMES_X(FOO_ADAPT)
#define FOO_ADAPT(num) FOO_FUNC(foo ## num)

#define FOO_FUNC bar
PRIMES_FOO_X

#undef  FOO_FUNC
#define FOO_FUNC(x) x();
PRIMES_FOO_X

Результат:

bar(foo2) bar(foo3) bar(foo5) bar(foo7)

foo2(); foo3(); foo5(); foo7();
Источник

(Примечание: это мой второй ответ на этот вопрос)

Вдохновленный ответом Х. Уолтерса с помощью Boost, я хотел найти решение только для Си. Отличный ответ Уильяма Свенсона на макрос Foreach по аргументам макросов, кажется, дает один.

Взяв код из его ответа, мы можем сгенерировать это решение:

// The first part here is taken from William Swanson's answer
// to https://stackru.com/questions/6707148
#define EVAL0(...) __VA_ARGS__
#define EVAL1(...) EVAL0(EVAL0(EVAL0(__VA_ARGS__)))
#define EVAL2(...) EVAL1(EVAL1(EVAL1(__VA_ARGS__)))
#define EVAL3(...) EVAL2(EVAL2(EVAL2(__VA_ARGS__)))
#define EVAL4(...) EVAL3(EVAL3(EVAL3(__VA_ARGS__)))
#define EVAL(...)  EVAL4(EVAL4(EVAL4(__VA_ARGS__)))

#define MAP_OUT
#define MAP_END(...)
#define MAP_GET_END() 0, MAP_END
#define MAP_NEXT0(item, next, ...) next MAP_OUT
#define MAP_NEXT1(item, next) MAP_NEXT0(item, next, 0)
#define MAP_NEXT(item, next)  MAP_NEXT1(MAP_GET_END item, next)

#define MAP0(f, x, peek, ...) f(x) MAP_NEXT(peek, MAP1)(f, peek, __VA_ARGS__)
#define MAP1(f, x, peek, ...) f(x) MAP_NEXT(peek, MAP0)(f, peek, __VA_ARGS__)
#define MAP(f, ...) EVAL(MAP1(f, __VA_ARGS__ (), 0))

// This is the example given by the OP:
#define PRIMES_X(func) \
  func(2) \
  func(3) \
  func(5) \
  func(7)

#define FOO_LIST(num) foo ## num, // note comma
#define PRIMES_FOO_X(f) MAP(f, PRIMES_X(FOO_LIST))

#define XXX(x) bar(x)
#define YYY(x) x();
PRIMES_FOO_X(XXX)
PRIMES_FOO_X(YYY)

Результат, используя gcc -E -P ..., является:

bar(foo2) bar(foo3) bar(foo5) bar(foo7)
foo2(); foo3(); foo5(); foo7();

Заметки:

  • В определении MAPМне пришлось удалить запятую после __VA_ARGS__ чтобы не допустить появления дополнительного значения мусора в конце. Но это нарушает макрос для других целей. Казалось бы, просто перемещая запятую в FOO_LIST бы исправить это, но это не так. (Todo: исправить)

  • Любое MAP-подобное или FOREACH-подобное решение, которое использует ## Оператор concatenate вряд ли будет работать здесь, потому что любой входной список, заданный макросом, не раскрывается. (Это было новым для меня:()

Изменить: второе альтернативное решение, использующее ту же идею, основано на коде из https://esolangs.org/wiki/ELIP. Вывод идентичен вышеуказанному. (И это показывает, что мой комментарий о ## не является правильным.)

// The first part here is based on esolangs.org/wiki/ELIP (CC0 public domain)
// (Note MAP here is their FOREACH)
#define XCAT(x,y) x ## y
#define CAT(x,y) XCAT(x,y)
#define EMPTY()
#define LPAREN (
#define RPAREN )
#define DEFER(x) x EMPTY()
#define EAT(...)
#define EXPAND(...) __VA_ARGS__
#define TRUE(x,...) x
#define FALSE(x,...) __VA_ARGS__
#define TRANSFORM(seq, ...) CAT(TRANSFORM1_A seq,0END)(EAT, __VA_ARGS__)
#define TRANSFORM1_A(...) (EXPAND, __VA_ARGS__)() TRANSFORM1_B
#define TRANSFORM1_B(...) (EXPAND, __VA_ARGS__)() TRANSFORM1_A
#define TRANSFORM1_A0END
#define TRANSFORM1_B0END
#define RPXFRM(m, ...) m(RPAREN RPXFRM_ID)
#define RPXFRM_ID() RPXFRM
#define INFUSE(seq, ...) INFUSE5(INFUSE1(TRANSFORM(seq), __VA_ARGS__))
#define INFUSE1(xfrm, ...) INFUSE2 xfrm, __VA_ARGS__ RPXFRM xfrm
#define INFUSE2(m, ...) m(INFUSE3 DEFER(XCAT)(LPA,REN)(__VA_ARGS__), INFUSE2_ID)
#define INFUSE2_ID() INFUSE2
#define INFUSE3(...) INFUSE4(__VA_ARGS__)
#define INFUSE4(x, rest, ...) (__VA_ARGS__, EXPAND x)() rest, __VA_ARGS__
#define INFUSE5(...) INFUSE6(__VA_ARGS__)
#define INFUSE6(...) INFUSE7(__VA_ARGS__)
#define INFUSE7(seq, ...) seq
#define MAP(macro, seq) EXPAND(MAP1 INFUSE(seq, TRUE, macro)(FALSE, EAT,))
#define MAP1(p, m, ...) m(__VA_ARGS__) p(MAP1_ID)
#define MAP1_ID() MAP1

// This is the example given by the OP:
#define PRIMES_X(func) \
  func(2) \
  func(3) \
  func(5) \
  func(7)

#define FOO_LIST(num) (foo ## num) // parentheses, no commas
#define PRIMES_FOO_X(f) MAP(f, PRIMES_X(FOO_LIST))

#define XXX(x) bar(x)
#define YYY(x) x();
PRIMES_FOO_X(XXX)
PRIMES_FOO_X(YYY)
Источник

Ключевое наблюдение... учитывая это:

#define PRIMES_X(func) \
  func(2) \
  func(3) \
  func(5) \
  func(7)

PRIMES_X() расширяется до (2) (3) (5) (7), что с точки зрения метапрограммирования CPP является структурой данных последовательности. Это в виду, давайте начнем идти в обратном направлении. Вы хотите что-то вроде этого:

#define PRIMES_FOO_X(func) \
  /* something that expands to: func(foo2) func(foo3) func(foo5) func(foo7) */

...и вы хотите foo2, foo3, foo5, foo7 приехать из PRIMES_X расширение. Очевидно тогда 2 становится foo2, 3 становится foo3, так далее; поэтому давайте предположим, что такие события происходят в соответствии с макросом FOOIDENT_OF, Затем в PRIMES_FOO_X тебе нужно позвонить func на (FOOIDENT_OF(2)), так далее; то есть вы хотите что-то более точное, как это:

#define PRIMES_FOO_X(func) \
  /* something that expands to: \
   * func(FOOIDENT_OF(2)) func(FOOIDENT_OF(3)) \
   * func(FOOIDENT_OF(5)) func(FOOIDENT_OF(7)) */

Объединяя две идеи, мы имеем следующие элементы:

  • func, операция для применения в производном X-макросе
  • FOOIDENT_OF, операция, которая преобразует каждый список аргументов X-макроса в новую форму
  • PRIMES_X()последовательность всех списков аргументов

Это возможно, и даже немного легко сделать, если мы используем последовательность препроцессора boost.

#include <boost/preprocessor/seq.hpp>

#define PAIR_ELEMENT_1(A,B) A
#define PAIR_ELEMENT_2(A,B) B

#define PAIR_XFORM_MACRO(r, data, elem) \
   PAIR_ELEMENT_1 data ( PAIR_ELEMENT_2 data (elem) )

#define PAIR_XFORM(PAIR_, SEQ_) \
   BOOST_PP_SEQ_FOR_EACH(PAIR_XFORM_MACRO, PAIR_, SEQ_)

Здесь у меня есть PAIR_XFORM он принимает 2-кортеж ("пару") макросов и применяет их к каждому элементу последовательности. IOW, PAIR_XFORM((func, FOOIDENT_OF), PRIMES_X()) генерирует нашу цель. Теперь все, что нам нужно, это создать новый X-макрос и создать внутренний макрос преобразования:

#define FOOIDENT_OF(N) foo##N
#define PRIMES_FOO_X(func) PAIR_XFORM((func, FOOIDENT_OF), PRIMES_X())

Вот как это выглядит на кучерявой кривой.

Источник

Попробуйте следующее решение:

#define PRIMES_X(func)                          \
  func(2) \
  func(3) \
  func(5) \
  func(7)

#define DERIVE_TOKEN(num) (foo##num);
#define FOO_ADAPT(f) f DERIVE_TOKEN
#define PRIMES_FOO_X(f) PRIMES_X(FOO_ADAPT(f))

Расширяется

PRIMES_FOO_X(funct)

в

funct (foo2); funct (foo3); funct (foo5); funct (foo7);
Источник
Другие вопросы по тегам