C Boost预处理器递归

我正在尝试创建一个“C”宏（不是C++），它将定义和初始化静态数据

例如：

STATIC_CONST_STRUCT
(
    A, a, 
    MEMBER_DATA(CONST_STR, a, "Hello, a")
    MEMBER_DATA(CONST_STR, b, "Hello, b")
    MEMBER_STRUCT
    (
        C, c, 
        MEMBER_DATA(CONST_STR, d, "Hello, d")
        MEMBER_DATA(CONST_INT, e, 1)
    )
);

将导致“C”预处理器创建：

static const struct A
{
    CONST_STR a;
    CONST_STR b;
    struct C
    {
        CONST_STR d;
        CONST_INT e;
    } c;
} =
{"Hello, a", "Hello, b", {"Hello, d", 1}};

我试过使用Boost预处理器

但我不太明白怎么做才行。我的宏停止扩展。我怀疑问题的递归本质是任意深度嵌套

我读到的关于让预处理器递归的解决方案要么不起作用，要么关于如何让递归起作用的描述不够清晰，无法实现一个有效的解决方案

以下是我目前掌握的情况：

#define MEMBER_DATA_TAG 0
#define MEMBER_STRUCT_TAG 1

#define MEMBER_TAG(MEMBER) BOOST_PP_SEQ_ELEM(0, MEMBER)

#define MEMBER_DATA_TYPE(MEMBER_DATA) BOOST_PP_SEQ_ELEM(1, MEMBER_DATA)
#define MEMBER_DATA_NAME(MEMBER_DATA) BOOST_PP_SEQ_ELEM(2, MEMBER_DATA)
#define MEMBER_DATA_VALUE(MEMBER_DATA) BOOST_PP_SEQ_ELEM(3, MEMBER_DATA)

#define MEMBER_STRUCT_TYPE(MEMBER_STRUCT) BOOST_PP_SEQ_ELEM(1, MEMBER_STRUCT)
#define MEMBER_STRUCT_NAME(MEMBER_STRUCT) BOOST_PP_SEQ_ELEM(2, MEMBER_STRUCT)
#define MEMBER_STRUCT_MEMBER_SEQ(MEMBER_STRUCT) BOOST_PP_SEQ_ELEM(3, MEMBER_STRUCT)

#define MEMBER_DATA(TYPE, NAME, VALUE) ((MEMBER_DATA_TAG)(TYPE)(NAME)(VALUE))
#define MEMBER_STRUCT(TYPE, NAME, MEMBER_SEQ) ((MEMBER_STRUCT_TAG)(TYPE)(NAME)(MEMBER_SEQ))

#define IS_MEMBER_STRUCT(MEMBER_SEQ_ELEM) BOOST_PP_EQUAL(MEMBER_TAG(MEMBER_SEQ_ELEM), MEMBER_STRUCT_TAG)

#define MEMBER_STRUCT_DECLARE(TYPE, NAME, MEMBER_SEQ)                            \
    struct TYPE                                                                  \
    {                                                                            \
        BOOST_PP_SEQ_FOR_EACH(MEMBER_ELEM_DECLARE, BOOST_PP_EMPTY(), MEMBER_SEQ) \
    } NAME

#define MEMBER_ELEM_DECLARE(_r, _data, MEMBER_SEQ_ELEM) \
    BOOST_PP_IIF                                        \
    (                                                   \
        IS_MEMBER_STRUCT(MEMBER_SEQ_ELEM),              \
        MEMBER_STRUCT_DECLARE                           \
        (                                               \
            MEMBER_STRUCT_TYPE(MEMBER_SEQ_ELEM),        \
            MEMBER_STRUCT_NAME(MEMBER_SEQ_ELEM),        \
            MEMBER_STRUCT_MEMBER_SEQ(MEMBER_SEQ_ELEM)   \
        ),                                              \
        MEMBER_DATA_DECLARE                             \
        (                                               \
            MEMBER_DATA_TYPE(MEMBER_SEQ_ELEM),          \
            MEMBER_DATA_NAME(MEMBER_SEQ_ELEM),          \
            MEMBER_DATA_VALUE(MEMBER_SEQ_ELEM)          \
        )                                               \
    );

#define MEMBER_DATA_DECLARE(TYPE, NAME, VALUE) TYPE NAME

#define MEMBER_VALUE_INIT(MEMBER_SEQ) \
    BOOST_PP_SEQ_FOR_EACH_I(MEMBER_VALUE_INIT_DECLARE, BOOST_PP_EMPTY(), MEMBER_SEQ);

#define MEMBER_VALUE_INIT_DECLARE(_r, _data, i, MEMBER_SEQ_ELEM) \
    BOOST_PP_COMMA_IF(i)                                         \
    BOOST_PP_IIF                                                 \
    (                                                            \
        IS_MEMBER_STRUCT(MEMBER_SEQ_ELEM),                       \
        {MEMBER_VALUE_INIT(MEMBER_SEQ_ELEM)},                    \
        MEMBER_DATA_VALUE(MEMBER_SEQ_ELEM)                       \
    )

#define STATIC_CONST_STRUCT(TYPE, NAME, MEMBER_SEQ)              \
    static const MEMBER_STRUCT_DECLARE(TYPE, NAME, MEMBER_SEQ) = \
    {                                                            \
         MEMBER_VALUE_INIT(MEMBER_SEQ)                           \
    }

---

谢谢。

与大多数程序员不同，我喜欢宏。但我告诉你，不要这样做。这听起来像是脚本语言的工作。我的目标是编写代码，从一个源代码生成Java和Objective-C。它不需要完全通用，只需要两个项目通用的位。在本例中，是一组具有某种嵌套结构的静态数据。Boost预处理器库似乎很理想，因为它在编译时会自动运行，并且非常接近于工作状态。Java将使用JNI，因此我最终也希望生成它。欢迎其他建议。