Re: [Boost-users] [Preprocessor] Is it possible to expand recursively?

Subject: Re: [Boost-users] [Preprocessor] Is it possible to expand recursively?
From: Edward Diener (eldiener_at_[hidden])
Date: 2011-07-19 09:55:29

On 7/18/2011 4:04 AM, TONGARI wrote:
> 2011/7/18 Edward Diener <eldiener_at_[hidden]
> <mailto:eldiener_at_[hidden]>>
>
>     On 7/17/2011 1:29 PM, Edward Diener wrote:
>
>         On 7/17/2011 9:21 AM, TONGARI wrote:
>
>             Hello,
>
>             I'd like to have a macro like:
>
>             BUILD_HIERARCHY
>             (a,
>             (b,)
>             (c,
>             (d,)
>             (e,)
>             )
>             )
>
>             which should expand to:
>
>             struct a {};
>             struct b: a {};
>             struct c: a {};
>             struct d: c {};
>             struct e: c {};
>
>             Is this possible at all?
>             I have tried but with no luck, if this is impossible, please
>             tell me so.
>
>
>         I think you want above:
>
>         (a,
>         (b)
>         (c,
>         (d)
>         (e)
>         )
>         )
>
>         This is a tuple with a possible second element as a seq. Each
>         element of
>         your seq is a tuple with the same rule as the top tuple.
>
>         Following internal logic, perhaps with nested BOOST_PP_WHILEs, you
>         should be able to cycle through each tuple and nested tuple
>         forming the
>         relationships you have created for your structs above. I can not
>         guarantee this will be doable but at least you should have some
>         idea of
>         what to do from the description of what you have.
>
>
>     I have to correct the above. The syntax for what I described must be:
>
>     (a,
>        ((b))
>        ((c,
>           (d)
>           (e))
>        )
>
>     )
>
>
> I think I need the comma since I don't assume variadic macro.

I do not understand what you mean by that, and what some extra comma has 
to do with variadic macros

I still do not have the above right. It should be:

(a,
    ((b))
    ((c,
        ((d))
        ((e))
     )
    )
)

In other words, each base-class/derived-classes relationship is a tuple 
where the first element is the base class name and where each optional 
second element is a sequence of derived classes in the form of your 
tuple again.

If you can not use variadic macros you can change your pp-tuples above 
to pp-arrays so you have the tuple size of either 1 or 2. So without 
variadic macros your relationship above would be:

(2,(a,
      ((1,(b)))
      ((2,(c,
          ((1,(d)))
          ((1,(e)))
       )
     )
    )
))

>
> This is what I had (not working, of course):
>
> #define PACK_2A( a1, a2 ) ((a1, a2)) PACK_2B
> #define PACK_2B( a1, a2 ) ((a1, a2)) PACK_2A
> #define PACK_2A_END
> #define PACK_2B_END
>
> #define BUILD_SUB( x, parent, child ) \
> struct BOOST_PP_TUPLE_ELEM(2, 0, child) : parent {};\
> BOOST_PP_SEQ_FOR_EACH\
> (\
>      BUILD_SUB, BOOST_PP_TUPLE_ELEM(2, 0, child)\
>    , BOOST_PP_CAT(BOOST_PP_EXPAND(PACK_2A BOOST_PP_TUPLE_ELEM(2, 1,
> child)), _END)\
> )
>
> #define BUILD_HIERARCHY( root, children ) \
> struct root {};\
> BOOST_PP_SEQ_FOR_EACH\
> (\
>      BUILD_SUB, root\
>    , BOOST_PP_CAT(PACK_2A children, _END)\
> )
>
> Obviously BUILD_SUB cannot be that way since the preprocessor disallows
> recursion.
> But even if I replace the recursive BUILD_SUB with something else the
> BOOST_PP_SEQ_FOR_EACH inside BUILD_SUB still fails to expand.
>
> I have no ideas :/

Just in case you do not know, you can use the Wave trace facility to see 
how your macros above are expanding when you invoke BUILD_HIERARCHY with 
your two parameters.