Am Dienstag, den 10.03.2020, 20:16 +0100 schrieb Florian Weimer via Liaison:
> * Jens Gustedt via Liaison:
>
> > The second is, that generic selection is a very nice tool to implement
> > traits and similar things. Just as an example from the reference
> > implementation that I am trying to build currently and that
> > simultaneously generates generic selections for C and overloaded
> > functions for C++:
> >
> > #define tohighest(X) _Generic((X),                                         \
> > signed char:    (signed char)(((unsigned char)-1)/2),\
> > signed short: (signed short)(((unsigned short)-1)/2),\
> > signed int: (signed int)(((unsigned int)-1)/2),\
> > signed long: (signed long)(((unsigned long)-1)/2),\
> > signed long long: (signed long long)(((unsigned long long)-1)/2),\
> > char: (char)(((unsigned char)-1)/(((char)-1 > 0) ? 1 : 2)),\
> > float: HUGE_VALF,\
> > double:                                               HUGE_VAL,\
> > long double:                                     HUGE_VALL,\
> > default: (generic_type(X))(((generic_type(X))-1)/(((generic_type(X))-1) < 0 ? 2 : 1)))
> >
> > (the real code I have for this is even shorter, but that's another story)
> >
> > Basically what the user has to write here is one line per type, which
> > is very concise and fits on one screen with a "tabular" layout (type
> > left, expression right). For C++ the generated code is 9 overloaded
> > functions and a template for the default case. This boiler plate
> > introduces a lot of possibilities for mistakes.
>
> That may be so, but you simply cannot use these lists in cases where
> any macro parameter is expanded more than once. Even for the default
> case in your example, you probably would have to use some lambda
> construct to capture the type of X, or you risk running into the same
> macro explosion issue we encountered with the original <tgmath.h>
> implementation in glibc.
>
> Do you think there is a mechanical way to capture types and values so
> that each macro argument is expanded exactly once? Perhaps using
> lambdas?

You can do this today using popular extensions:

#define FOO(x) ({ __auto_type __x = (x); _Generic(__x, ... ); })



Best,
Martin