Compiler Explorer

Source code

// Scroll to the bottom and try using the macro there.

/* A boilerplate generation helper. Duplicates `...` once for each element in `seq_`, replacing placeholders with the list elements.
`seq_` is a list of the form `(a,b,c)(...)(...)`.
Additionally each element (such as `a`,`b`,`c`) can be parenthesized (e.g. if it needs to contain commas),
  the parentheses are removed automatically (but at most once per element, use `((a))` to get `(a)` in the expansion).

Placeholders in the `...` are `EM_i` (or `_i_` iF `SHORT_MACROS[_CODEGEN]` is enabled), which expands to `seq_[??][i]`.
If a placeholder appears inside of `(...)`, the parentheses must be preceded by `EM_P` (shortens to `_P_`).
There are also optional placeholders `EM_i_OPT` (shorten to `_i_OPT_) that expand to nothing if not provided, instead of causing an error.
`sep_` is a separator that's inserted between expansion. It can be parenthesized, the parentheses are stripepd (e.g. `(,)` to insert a comma).

Examples:
 1. EM_CODEGEN(
        (x,1)(y,2)(z,3),,
        int EM_1 = EM_2;
    )
    Expands to:
      int x = 1; int y = 2; int z = 3;

2. int EM_CODEGEN(
        (a,(1,2,3))(b,(4,5,6)), // Parentheses allow for commas in the elements, they are removed automatically.
        (,), // Separator: comma.
        EM_1[] = {EM_2}
    );
    Expands to:
      int a[] = {1, 2, 3}, b[] = {4, 5, 6};

3. const char EM_CODEGEN(
        (a)(b),
        (,),
        *EM_1 = EM_STR EM_P(EM_1)
    );
    Expands to:
      const char *a = "a", *b = "b";

4. // An imitation of `EM_MAYBE_CONST_LR` from `utils/cvref.h`.
    #define MAYBE_CONST_LR(...) \
        EM_CODEGEN_LOW( \
            , \
            (      & ,         ((*this))) \      // Need additional `(...)` because the one set of parentheses will get automatically removed.
            (const & ,         ((*this))) \
            (      &&, std::move(*this) ) \
            (const &&, std::move(*this) ), \
            (), \
            (__VA_ARGS__) \
        )

#define QUAL EM_1
    #define FWD_SELF EM_2

struct A
    {
        int x;

MAYBE_CONST_LR(
            int QUAL foo() QUAL {return FWD_SELF.x;}
        )

// Expands to:
        // int &foo() & {return (*this).x;}
        // int const &foo() const & {return (*this).x;}
        // int &&foo() && {return std::move(*this).x;}
        // int const &&foo() const && {return std ::move(*this).x;}
    };

5. // A enum with a string conversion and optional values.
    #define MAKE_ENUM(E, elems) \
        enum class E { \
            EM_CODEGEN(elems,, EM_1 MAYBE_INIT EM_P(EM_2_OPT),) \    // Could also use `EM_1 EM_2_OPT` directly, changing the syntax to `(a,=42)`.
        }; \
        std::string ToString(E e) \
        { \
            switch (e) { EM_CODEGEN(elems,, case E::EM_1: return EM_STR EM_P(EM_1);) } \
        }
    #define MAYBE_INIT(...) __VA_OPT__(= __VA_ARGS__)

MAKE_ENUM( E,
        (a,10)
        (b)
        (c,20)
    )
*/
#define EM_CODEGEN(seq_, sep_, .../*pattern*/) EM_CODEGEN_LOW(, seq_, sep_, (__VA_ARGS__))
// A lower-level version.
// Firstly, takes `n` (loop depth) to support calls inside of `SF_FOR_EACH` loops.
// Second, `pattern_` must be already parenthesized (it can't be passed between macros when unparenthesized).
#define EM_CODEGEN_LOW(n, seq_, sep_, pattern_) DETAIL_EM_CODEGEN_IDENTITY( SF_CAT(SF_FOR_EACH,n)(DETAIL_EM_CODEGEN_OUTER_BODY, DETAIL_EM_CODEGEN_OUTER_STEP, SF_NULL, (EM_EMPTY, sep_, pattern_), seq_) )
// ^ Wrapping everything in `DETAIL_EM_CODEGEN_IDENTITY(...)` to expand the `MACRO _P_(...)` pattern.

#define DETAIL_EM_CAT(x,y) x##y
#define DETAIL_EM_CAT3(x,y,z) x##y##z
#define DETAIL_EM_CAT4(x,y,z,w) x##y##z##w
#define DETAIL_EM_CGBITS_1(...) EM_TRY_EXPAND_PARENS(EM_VA_AT0(__VA_ARGS__))
#define DETAIL_EM_CGBITS_1_OPT(...) EM_TRY_EXPAND_PARENS(EM_VA_TRY_AT0(__VA_ARGS__))
#define DETAIL_EM_CGBITS_2(...) EM_TRY_EXPAND_PARENS(EM_VA_AT1(__VA_ARGS__))
#define DETAIL_EM_CGBITS_2_OPT(...) EM_TRY_EXPAND_PARENS(EM_VA_TRY_AT1(__VA_ARGS__))
#define DETAIL_EM_CGBITS_3(...) EM_TRY_EXPAND_PARENS(EM_VA_AT2(__VA_ARGS__))
#define DETAIL_EM_CGBITS_3_OPT(...) EM_TRY_EXPAND_PARENS(EM_VA_TRY_AT2(__VA_ARGS__))
#define DETAIL_EM_CGBITS_4(...) EM_TRY_EXPAND_PARENS(EM_VA_AT3(__VA_ARGS__))
#define DETAIL_EM_CGBITS_4_OPT(...) EM_TRY_EXPAND_PARENS(EM_VA_TRY_AT3(__VA_ARGS__))
#define DETAIL_EM_CGBITS_5(...) EM_TRY_EXPAND_PARENS(EM_VA_AT4(__VA_ARGS__))
#define DETAIL_EM_CGBITS_5_OPT(...) EM_TRY_EXPAND_PARENS(EM_VA_TRY_AT4(__VA_ARGS__))
#define DETAIL_EM_CGBITS_6(...) EM_TRY_EXPAND_PARENS(EM_VA_AT5(__VA_ARGS__))
#define DETAIL_EM_CGBITS_6_OPT(...) EM_TRY_EXPAND_PARENS(EM_VA_TRY_AT5(__VA_ARGS__))
#define DETAIL_EM_CGBITS_7(...) EM_TRY_EXPAND_PARENS(EM_VA_AT6(__VA_ARGS__))
#define DETAIL_EM_CGBITS_7_OPT(...) EM_TRY_EXPAND_PARENS(EM_VA_TRY_AT6(__VA_ARGS__))
#define DETAIL_EM_CGBITS_8(...) EM_TRY_EXPAND_PARENS(EM_VA_AT7(__VA_ARGS__))
#define DETAIL_EM_CGBITS_8_OPT(...) EM_TRY_EXPAND_PARENS(EM_VA_TRY_AT7(__VA_ARGS__))
#define DETAIL_EM_CGBITS_LPAREN(...) (
#define DETAIL_EM_CGBITS_RPAREN(...) )
#define DETAIL_EM_CLASSIFY_LIST(...) DETAIL_EM_CLASSIFY_LIST_APPLY(DETAIL_EM_CLASSIFY_LIST_DETECT_SEQ __VA_ARGS__)
#define DETAIL_EM_CLASSIFY_LIST_APPLY(...) DETAIL_EM_CLASSIFY_LIST_APPLY_(__VA_ARGS__) )
#define DETAIL_EM_CLASSIFY_LIST_APPLY_(...) DETAIL_EM_CLASSIFY_LIST_CHECK_##__VA_ARGS__
#define DETAIL_EM_CLASSIFY_LIST_CHECK_DETAIL_EM_CLASSIFY_LIST_DETECTED_SEQ SEQ DETAIL_EM_CLASSIFY_LIST_EMPTY(
#define DETAIL_EM_CLASSIFY_LIST_CHECK_DETAIL_EM_CLASSIFY_LIST_DETECT_SEQ VA DETAIL_EM_CLASSIFY_LIST_EMPTY(
#define DETAIL_EM_CLASSIFY_LIST_DETECT_SEQ(...) DETAIL_EM_CLASSIFY_LIST_DETECTED_SEQ(__VA_ARGS__)
#define DETAIL_EM_CLASSIFY_LIST_EMPTY(...) 
#define DETAIL_EM_CODEGEN_ACT_0(repls_,...) __VA_ARGS__
#define DETAIL_EM_CODEGEN_ACT_1(repls_,m,...) m(DETAIL_EM_CODEGEN_IDENTITY repls_) __VA_ARGS__
#define DETAIL_EM_CODEGEN_BODY(n,d,...) DETAIL_EM_CODEGEN_BODY_0(n, DETAIL_EM_CODEGEN_IDENTITY d, __VA_ARGS__)
#define DETAIL_EM_CODEGEN_BODY_0(...) DETAIL_EM_CODEGEN_BODY_1(__VA_ARGS__)
#define DETAIL_EM_CODEGEN_BODY_1(n,m,...) m(__VA_ARGS__)
#define DETAIL_EM_CODEGEN_IDENTITY(...) __VA_ARGS__
#define DETAIL_EM_CODEGEN_OUTER_BODY(n,sepfunc_sep_pattern_,...) DETAIL_EM_CODEGEN_OUTER_BODY_0(n, DETAIL_EM_CODEGEN_IDENTITY sepfunc_sep_pattern_, __VA_ARGS__)
#define DETAIL_EM_CODEGEN_OUTER_BODY_0(...) DETAIL_EM_CODEGEN_OUTER_BODY_1(__VA_ARGS__)
#define DETAIL_EM_CODEGEN_OUTER_BODY_1(n,sepfunc_,sep_,pattern_,...) sepfunc_(sep_) SF_CAT(SF_FOR_EACH,n)(DETAIL_EM_CODEGEN_BODY, DETAIL_EM_CODEGEN_STEP, SF_NULL, (DETAIL_EM_CODEGEN_ACT_0, (__VA_ARGS__)), pattern_)
#define DETAIL_EM_CODEGEN_OUTER_STEP(n,sepfunc_sep_pattern_,...) DETAIL_EM_CODEGEN_OUTER_STEP_0(DETAIL_EM_CODEGEN_IDENTITY sepfunc_sep_pattern_)
#define DETAIL_EM_CODEGEN_OUTER_STEP_0(...) DETAIL_EM_CODEGEN_OUTER_STEP_1(__VA_ARGS__)
#define DETAIL_EM_CODEGEN_OUTER_STEP_1(sepfunc_,sep_,pattern_) (EM_TRY_EXPAND_PARENS, sep_, pattern_)
#define DETAIL_EM_CODEGEN_STEP(n,d,...) DETAIL_EM_CODEGEN_STEP_0(DETAIL_EM_CODEGEN_IDENTITY d)
#define DETAIL_EM_CODEGEN_STEP_0(...) DETAIL_EM_CODEGEN_STEP_1(__VA_ARGS__)
#define DETAIL_EM_CODEGEN_STEP_1(m,...) (DETAIL_EM_CODEGEN_ACT_1, __VA_ARGS__)
#define DETAIL_EM_ENABLE_KEYWORD_MACROS1(x) DETAIL_EM_ENABLE_KEYWORD_MACROS4(DETAIL_EM_ENABLE_KEYWORD_MACROS2(x)(), DETAIL_EM_ENABLE_KEYWORD_MACROS4_DEF, DETAIL_EM_ENABLE_KEYWORD_MACROS4_UNDEF,)
#define DETAIL_EM_ENABLE_KEYWORD_MACROS2(...) DETAIL_EM_ENABLE_KEYWORD_MACROS3_##__VA_ARGS__
#define DETAIL_EM_ENABLE_KEYWORD_MACROS3_() 1,x
#define DETAIL_EM_ENABLE_KEYWORD_MACROS3_0() 0,x
#define DETAIL_EM_ENABLE_KEYWORD_MACROS3_1() 1,x
#define DETAIL_EM_ENABLE_KEYWORD_MACROS4(...) DETAIL_EM_ENABLE_KEYWORD_MACROS5(__VA_ARGS__)
#define DETAIL_EM_ENABLE_KEYWORD_MACROS4_DEF(x) x
#define DETAIL_EM_ENABLE_KEYWORD_MACROS4_UNDEF(...) DETAIL_EM_ENABLE_KEYWORD_MACROS6(EM_KEYWORD_MACROS)
#define DETAIL_EM_ENABLE_KEYWORD_MACROS5(...) DETAIL_EM_ENABLE_KEYWORD_MACROS5_(__VA_ARGS__)
#define DETAIL_EM_ENABLE_KEYWORD_MACROS5_(x,y,z,...) z(x)
#define DETAIL_EM_ENABLE_KEYWORD_MACROS6(x) DETAIL_EM_ENABLE_KEYWORD_MACROS6_(x)
#define DETAIL_EM_ENABLE_KEYWORD_MACROS6_(...) DETAIL_EM_ENABLE_KEYWORD_MACROS7_##__VA_ARGS__()
#define DETAIL_EM_ENABLE_KEYWORD_MACROS7_() 1
#define DETAIL_EM_ENABLE_KEYWORD_MACROS7_0() 0
#define DETAIL_EM_ENABLE_KEYWORD_MACROS7_1() 1
#define DETAIL_EM_ENABLE_KEYWORD_MACROS7_EM_KEYWORD_MACROS() 0
#define DETAIL_EM_ENABLE_SHORT_MACROS1(x) DETAIL_EM_ENABLE_SHORT_MACROS4(DETAIL_EM_ENABLE_SHORT_MACROS2(x)(), DETAIL_EM_ENABLE_SHORT_MACROS4_DEF, DETAIL_EM_ENABLE_SHORT_MACROS4_UNDEF,)
#define DETAIL_EM_ENABLE_SHORT_MACROS2(...) DETAIL_EM_ENABLE_SHORT_MACROS3_##__VA_ARGS__
#define DETAIL_EM_ENABLE_SHORT_MACROS3_() 1,x
#define DETAIL_EM_ENABLE_SHORT_MACROS3_0() 0,x
#define DETAIL_EM_ENABLE_SHORT_MACROS3_1() 1,x
#define DETAIL_EM_ENABLE_SHORT_MACROS4(...) DETAIL_EM_ENABLE_SHORT_MACROS5(__VA_ARGS__)
#define DETAIL_EM_ENABLE_SHORT_MACROS4_DEF(x) x
#define DETAIL_EM_ENABLE_SHORT_MACROS4_UNDEF(...) DETAIL_EM_ENABLE_SHORT_MACROS6(EM_SHORT_MACROS)
#define DETAIL_EM_ENABLE_SHORT_MACROS5(...) DETAIL_EM_ENABLE_SHORT_MACROS5_(__VA_ARGS__)
#define DETAIL_EM_ENABLE_SHORT_MACROS5_(x,y,z,...) z(x)
#define DETAIL_EM_ENABLE_SHORT_MACROS6(x) DETAIL_EM_ENABLE_SHORT_MACROS6_(x)
#define DETAIL_EM_ENABLE_SHORT_MACROS6_(...) DETAIL_EM_ENABLE_SHORT_MACROS7_##__VA_ARGS__()
#define DETAIL_EM_ENABLE_SHORT_MACROS7_() 1
#define DETAIL_EM_ENABLE_SHORT_MACROS7_0() 0
#define DETAIL_EM_ENABLE_SHORT_MACROS7_1() 1
#define DETAIL_EM_ENABLE_SHORT_MACROS7_EM_SHORT_MACROS() 0
#define DETAIL_EM_END(...) __VA_ARGS__##_end
#define DETAIL_EM_PARENS_BAKE_DETAIL_EM_PARENS_GRAB (),
#define DETAIL_EM_PARENS_BAKE_DETAIL_EM_PARENS_GRABBED 
#define DETAIL_EM_PARENS_BAKE_MACRO(...) DETAIL_EM_PARENS_BAKE_MACRO_(__VA_ARGS__)
#define DETAIL_EM_PARENS_BAKE_MACRO_(...) DETAIL_EM_PARENS_BAKE_##__VA_ARGS__
#define DETAIL_EM_PARENS_GRAB(...) DETAIL_EM_PARENS_GRABBED(__VA_ARGS__),
#define DETAIL_EM_PARENS_NO_FIRST(...) DETAIL_EM_PARENS_NO_FIRST_(__VA_ARGS__)
#define DETAIL_EM_PARENS_NO_FIRST_(x,...) __VA_ARGS__
#define DETAIL_EM_SEQ_AT0(...) __VA_ARGS__ EM_EMPTY(
#define DETAIL_EM_SEQ_FIRST(...) __VA_ARGS__ EM_EMPTY(
#define DETAIL_EM_STR(...) #__VA_ARGS__
#define DETAIL_EM_TRY_EXPAND_PARENS(...) DETAIL_EM_TRY_EXPAND_PARENS_(__VA_ARGS__)
#define DETAIL_EM_TRY_EXPAND_PARENS_(...) DETAIL_EM_TRY_EXPAND_PARENS_##__VA_ARGS__
#define DETAIL_EM_TRY_EXPAND_PARENS_DETAIL_EM_TRY_EXPAND_PARENS_EXPANDED 
#define DETAIL_EM_TRY_EXPAND_PARENS_DETAIL_EM_TRY_EXPAND_PARENS_IDENTITY 
#define DETAIL_EM_TRY_EXPAND_PARENS_IDENTITY(...) DETAIL_EM_TRY_EXPAND_PARENS_EXPANDED __VA_ARGS__
#define EM_1 )(DETAIL_EM_CGBITS_1,
#define EM_1_OPT )(DETAIL_EM_CGBITS_1_OPT,
#define EM_2 )(DETAIL_EM_CGBITS_2,
#define EM_2_OPT )(DETAIL_EM_CGBITS_2_OPT,
#define EM_3 )(DETAIL_EM_CGBITS_3,
#define EM_3_OPT )(DETAIL_EM_CGBITS_3_OPT,
#define EM_4 )(DETAIL_EM_CGBITS_4,
#define EM_4_OPT )(DETAIL_EM_CGBITS_4_OPT,
#define EM_5 )(DETAIL_EM_CGBITS_5,
#define EM_5_OPT )(DETAIL_EM_CGBITS_5_OPT,
#define EM_6 )(DETAIL_EM_CGBITS_6,
#define EM_6_OPT )(DETAIL_EM_CGBITS_6_OPT,
#define EM_7 )(DETAIL_EM_CGBITS_7,
#define EM_7_OPT )(DETAIL_EM_CGBITS_7_OPT,
#define EM_8 )(DETAIL_EM_CGBITS_8,
#define EM_8_OPT )(DETAIL_EM_CGBITS_8_OPT,
#define EM_CAT(x,y) DETAIL_EM_CAT(x, y)
#define EM_CAT3(x,y,z) DETAIL_EM_CAT3(x, y, z)
#define EM_CAT4(x,y,z,w) DETAIL_EM_CAT4(x, y, z, w)
#define EM_CLASSIFY_LIST(...) DETAIL_EM_CLASSIFY_LIST(__VA_ARGS__)
#define EM_COMMA(...) ,
#define EM_EMPTY(...) 
#define EM_ENABLE_KEYWORD_MACROS(name) DETAIL_EM_ENABLE_KEYWORD_MACROS1(EM_KEYWORD_MACROS_##name)
#define EM_ENABLE_SHORT_MACROS(name) DETAIL_EM_ENABLE_SHORT_MACROS1(EM_SHORT_MACROS_##name)
#define EM_END(...) DETAIL_EM_END(__VA_ARGS__)
#define EM_HAS_VA_OPT 1
#define EM_IDENTITY(...) __VA_ARGS__
#define EM_IDENTITY_A(...) __VA_ARGS__
#define EM_IDENTITY_B(...) __VA_ARGS__
#define EM_IDENTITY_C(...) __VA_ARGS__
#define EM_IDENTITY_D(...) __VA_ARGS__
#define EM_IS_LEGACY_MSVC_PREPROCESSOR 0
#define EM_IS_LEGACY_MSVC_PREPROCESSOR_CLANG_IMITATION 0
#define EM_LPAREN(...) (
#define EM_P(...) )(DETAIL_EM_CGBITS_LPAREN,__VA_ARGS__)(DETAIL_EM_CGBITS_RPAREN,
#define EM_RPAREN(...) )
#define EM_SEQ_AT(i,...) EM_CAT(EM_SEQ_AT,i)(__VA_ARGS__)
#define EM_SEQ_AT0(...) DETAIL_EM_SEQ_AT0 __VA_ARGS__ )
#define EM_SEQ_AT1(...) EM_SEQ_AT0(EM_EMPTY __VA_ARGS__)
#define EM_SEQ_AT2(...) EM_SEQ_AT1(EM_EMPTY __VA_ARGS__)
#define EM_SEQ_AT3(...) EM_SEQ_AT2(EM_EMPTY __VA_ARGS__)
#define EM_SEQ_AT4(...) EM_SEQ_AT3(EM_EMPTY __VA_ARGS__)
#define EM_SEQ_AT5(...) EM_SEQ_AT4(EM_EMPTY __VA_ARGS__)
#define EM_SEQ_AT6(...) EM_SEQ_AT5(EM_EMPTY __VA_ARGS__)
#define EM_SEQ_AT7(...) EM_SEQ_AT6(EM_EMPTY __VA_ARGS__)
#define EM_SEQ_FIRST(...) DETAIL_EM_SEQ_FIRST __VA_ARGS__ )
#define EM_SEQ_TRY_AT(i,...) EM_CAT(EM_SEQ_TRY_AT,i)(__VA_ARGS__)
#define EM_SEQ_TRY_AT0(...) EM_TRY_ONLY_PARENS(__VA_ARGS__)
#define EM_SEQ_TRY_AT1(...) EM_SEQ_TRY_AT0(EM_TRY_SKIP_PARENS(__VA_ARGS__))
#define EM_SEQ_TRY_AT2(...) EM_SEQ_TRY_AT1(EM_TRY_SKIP_PARENS(__VA_ARGS__))
#define EM_SEQ_TRY_AT3(...) EM_SEQ_TRY_AT2(EM_TRY_SKIP_PARENS(__VA_ARGS__))
#define EM_SEQ_TRY_AT4(...) EM_SEQ_TRY_AT3(EM_TRY_SKIP_PARENS(__VA_ARGS__))
#define EM_SEQ_TRY_AT5(...) EM_SEQ_TRY_AT4(EM_TRY_SKIP_PARENS(__VA_ARGS__))
#define EM_SEQ_TRY_AT6(...) EM_SEQ_TRY_AT5(EM_TRY_SKIP_PARENS(__VA_ARGS__))
#define EM_SEQ_TRY_AT7(...) EM_SEQ_TRY_AT6(EM_TRY_SKIP_PARENS(__VA_ARGS__))
#define EM_SHORT_MACROS 
#define EM_STR(...) DETAIL_EM_STR(__VA_ARGS__)
#define EM_SYMBOL_AND(...) &&
#define EM_SYMBOL_OR(...) ||
#define EM_TRY_EXPAND_PARENS(...) DETAIL_EM_TRY_EXPAND_PARENS(DETAIL_EM_TRY_EXPAND_PARENS_IDENTITY __VA_ARGS__)
#define EM_TRY_ONLY_PARENS(...) EM_SEQ_FIRST(DETAIL_EM_PARENS_BAKE_MACRO(DETAIL_EM_PARENS_GRAB __VA_ARGS__))
#define EM_TRY_SKIP_PARENS(...) DETAIL_EM_PARENS_NO_FIRST(DETAIL_EM_PARENS_BAKE_MACRO(DETAIL_EM_PARENS_GRAB __VA_ARGS__))
#define EM_VA_AT(i,...) EM_CAT(EM_VA_AT,i)(__VA_ARGS__)
#define EM_VA_AT0(x,...) x
#define EM_VA_AT1(p1,x,...) x
#define EM_VA_AT2(p1,p2,x,...) x
#define EM_VA_AT3(p1,p2,p3,x,...) x
#define EM_VA_AT4(p1,p2,p3,p4,x,...) x
#define EM_VA_AT5(p1,p2,p3,p4,p5,x,...) x
#define EM_VA_AT6(p1,p2,p3,p4,p5,p6,x,...) x
#define EM_VA_AT7(p1,p2,p3,p4,p5,p6,p7,x,...) x
#define EM_VA_OR_SEQ_AT(i,...) EM_CAT4(EM_, EM_CLASSIFY_LIST(__VA_ARGS__), _AT, i)(__VA_ARGS__)
#define EM_VA_OR_SEQ_TRY_AT(i,...) EM_CAT4(EM_, EM_CLASSIFY_LIST(__VA_ARGS__), _TRY_AT, i)(__VA_ARGS__)
#define EM_VA_TRY_AT0(x,...) x
#define EM_VA_TRY_AT1(x,...) __VA_OPT__(EM_VA_TRY_AT0(__VA_ARGS__))
#define EM_VA_TRY_AT2(x,...) __VA_OPT__(EM_VA_TRY_AT1(__VA_ARGS__))
#define EM_VA_TRY_AT3(x,...) __VA_OPT__(EM_VA_TRY_AT2(__VA_ARGS__))
#define EM_VA_TRY_AT4(x,...) __VA_OPT__(EM_VA_TRY_AT3(__VA_ARGS__))
#define EM_VA_TRY_AT5(x,...) __VA_OPT__(EM_VA_TRY_AT4(__VA_ARGS__))
#define EM_VA_TRY_AT6(x,...) __VA_OPT__(EM_VA_TRY_AT5(__VA_ARGS__))
#define EM_VA_TRY_AT7(x,...) __VA_OPT__(EM_VA_TRY_AT6(__VA_ARGS__))
#define IMPL_SEQFOR_ANNOTATE_SEQ_A(...) ()(__VA_ARGS__)IMPL_SEQFOR_ANNOTATE_SEQ_B
#define IMPL_SEQFOR_ANNOTATE_SEQ_A_END 
#define IMPL_SEQFOR_ANNOTATE_SEQ_B(...) ()(__VA_ARGS__)IMPL_SEQFOR_ANNOTATE_SEQ_A
#define IMPL_SEQFOR_ANNOTATE_SEQ_B_END 
#define IMPL_SEQFOR_ANNOTATE_SEQ_END(x) IMPL_SEQFOR_ANNOTATE_SEQ_END_(x)(0)
#define IMPL_SEQFOR_ANNOTATE_SEQ_END_(x) x##_END
#define IMPL_SEQFOR_CAT(x,y) IMPL_SEQFOR_CAT_(x,y)
#define IMPL_SEQFOR_CAT_(x,y) x##y
#define IMPL_SEQFOR_FOR(m,s,f,d,guide) IMPL_SEQFOR_IDENTITY( IMPL_SEQFOR_FOR_GUIDE_A IMPL_SEQFOR_LPAREN m, s, f, d, guide )
#define IMPL_SEQFOR_FOR0(m,s,f,d,guide) IMPL_SEQFOR_IDENTITY0( IMPL_SEQFOR_FOR_GUIDE0_A IMPL_SEQFOR_LPAREN m, s, f, d, guide )
#define IMPL_SEQFOR_FOR1(m,s,f,d,guide) IMPL_SEQFOR_IDENTITY1( IMPL_SEQFOR_FOR_GUIDE1_A IMPL_SEQFOR_LPAREN m, s, f, d, guide )
#define IMPL_SEQFOR_FOR2(m,s,f,d,guide) IMPL_SEQFOR_IDENTITY2( IMPL_SEQFOR_FOR_GUIDE2_A IMPL_SEQFOR_LPAREN m, s, f, d, guide )
#define IMPL_SEQFOR_FOR3(m,s,f,d,guide) IMPL_SEQFOR_IDENTITY3( IMPL_SEQFOR_FOR_GUIDE3_A IMPL_SEQFOR_LPAREN m, s, f, d, guide )
#define IMPL_SEQFOR_FOR4(m,s,f,d,guide) IMPL_SEQFOR_IDENTITY4( IMPL_SEQFOR_FOR_GUIDE4_A IMPL_SEQFOR_LPAREN m, s, f, d, guide )
#define IMPL_SEQFOR_FOR5(m,s,f,d,guide) IMPL_SEQFOR_IDENTITY5( IMPL_SEQFOR_FOR_GUIDE5_A IMPL_SEQFOR_LPAREN m, s, f, d, guide )
#define IMPL_SEQFOR_FOR6(m,s,f,d,guide) IMPL_SEQFOR_IDENTITY6( IMPL_SEQFOR_FOR_GUIDE6_A IMPL_SEQFOR_LPAREN m, s, f, d, guide )
#define IMPL_SEQFOR_FOR7(m,s,f,d,guide) IMPL_SEQFOR_IDENTITY7( IMPL_SEQFOR_FOR_GUIDE7_A IMPL_SEQFOR_LPAREN m, s, f, d, guide )
#define IMPL_SEQFOR_FOR_GUIDE0_A(m,s,f,d,e) IMPL_SEQFOR_CAT(IMPL_SEQFOR_FOR_GUIDE0_A_, e)(m, s, f, d)
#define IMPL_SEQFOR_FOR_GUIDE0_A_(m,s,f,d) IMPL_SEQFOR_FOR_GUIDE0_B(m, s, f, d,
#define IMPL_SEQFOR_FOR_GUIDE0_A_0(m,s,f,d) f(1, d) IMPL_SEQFOR_NULL(
#define IMPL_SEQFOR_FOR_GUIDE0_B(m,s,f,d,...) m(1, d, __VA_ARGS__) IMPL_SEQFOR_FOR_GUIDE0_A(m, s, f, s(1, d, __VA_ARGS__),
#define IMPL_SEQFOR_FOR_GUIDE1_A(m,s,f,d,e) IMPL_SEQFOR_CAT(IMPL_SEQFOR_FOR_GUIDE1_A_, e)(m, s, f, d)
#define IMPL_SEQFOR_FOR_GUIDE1_A_(m,s,f,d) IMPL_SEQFOR_FOR_GUIDE1_B(m, s, f, d,
#define IMPL_SEQFOR_FOR_GUIDE1_A_0(m,s,f,d) f(2, d) IMPL_SEQFOR_NULL(
#define IMPL_SEQFOR_FOR_GUIDE1_B(m,s,f,d,...) m(2, d, __VA_ARGS__) IMPL_SEQFOR_FOR_GUIDE1_A(m, s, f, s(2, d, __VA_ARGS__),
#define IMPL_SEQFOR_FOR_GUIDE2_A(m,s,f,d,e) IMPL_SEQFOR_CAT(IMPL_SEQFOR_FOR_GUIDE2_A_, e)(m, s, f, d)
#define IMPL_SEQFOR_FOR_GUIDE2_A_(m,s,f,d) IMPL_SEQFOR_FOR_GUIDE2_B(m, s, f, d,
#define IMPL_SEQFOR_FOR_GUIDE2_A_0(m,s,f,d) f(3, d) IMPL_SEQFOR_NULL(
#define IMPL_SEQFOR_FOR_GUIDE2_B(m,s,f,d,...) m(3, d, __VA_ARGS__) IMPL_SEQFOR_FOR_GUIDE2_A(m, s, f, s(3, d, __VA_ARGS__),
#define IMPL_SEQFOR_FOR_GUIDE3_A(m,s,f,d,e) IMPL_SEQFOR_CAT(IMPL_SEQFOR_FOR_GUIDE3_A_, e)(m, s, f, d)
#define IMPL_SEQFOR_FOR_GUIDE3_A_(m,s,f,d) IMPL_SEQFOR_FOR_GUIDE3_B(m, s, f, d,
#define IMPL_SEQFOR_FOR_GUIDE3_A_0(m,s,f,d) f(4, d) IMPL_SEQFOR_NULL(
#define IMPL_SEQFOR_FOR_GUIDE3_B(m,s,f,d,...) m(4, d, __VA_ARGS__) IMPL_SEQFOR_FOR_GUIDE3_A(m, s, f, s(4, d, __VA_ARGS__),
#define IMPL_SEQFOR_FOR_GUIDE4_A(m,s,f,d,e) IMPL_SEQFOR_CAT(IMPL_SEQFOR_FOR_GUIDE4_A_, e)(m, s, f, d)
#define IMPL_SEQFOR_FOR_GUIDE4_A_(m,s,f,d) IMPL_SEQFOR_FOR_GUIDE4_B(m, s, f, d,
#define IMPL_SEQFOR_FOR_GUIDE4_A_0(m,s,f,d) f(5, d) IMPL_SEQFOR_NULL(
#define IMPL_SEQFOR_FOR_GUIDE4_B(m,s,f,d,...) m(5, d, __VA_ARGS__) IMPL_SEQFOR_FOR_GUIDE4_A(m, s, f, s(5, d, __VA_ARGS__),
#define IMPL_SEQFOR_FOR_GUIDE5_A(m,s,f,d,e) IMPL_SEQFOR_CAT(IMPL_SEQFOR_FOR_GUIDE5_A_, e)(m, s, f, d)
#define IMPL_SEQFOR_FOR_GUIDE5_A_(m,s,f,d) IMPL_SEQFOR_FOR_GUIDE5_B(m, s, f, d,
#define IMPL_SEQFOR_FOR_GUIDE5_A_0(m,s,f,d) f(6, d) IMPL_SEQFOR_NULL(
#define IMPL_SEQFOR_FOR_GUIDE5_B(m,s,f,d,...) m(6, d, __VA_ARGS__) IMPL_SEQFOR_FOR_GUIDE5_A(m, s, f, s(6, d, __VA_ARGS__),
#define IMPL_SEQFOR_FOR_GUIDE6_A(m,s,f,d,e) IMPL_SEQFOR_CAT(IMPL_SEQFOR_FOR_GUIDE6_A_, e)(m, s, f, d)
#define IMPL_SEQFOR_FOR_GUIDE6_A_(m,s,f,d) IMPL_SEQFOR_FOR_GUIDE6_B(m, s, f, d,
#define IMPL_SEQFOR_FOR_GUIDE6_A_0(m,s,f,d) f(7, d) IMPL_SEQFOR_NULL(
#define IMPL_SEQFOR_FOR_GUIDE6_B(m,s,f,d,...) m(7, d, __VA_ARGS__) IMPL_SEQFOR_FOR_GUIDE6_A(m, s, f, s(7, d, __VA_ARGS__),
#define IMPL_SEQFOR_FOR_GUIDE7_A(m,s,f,d,e) IMPL_SEQFOR_CAT(IMPL_SEQFOR_FOR_GUIDE7_A_, e)(m, s, f, d)
#define IMPL_SEQFOR_FOR_GUIDE7_A_(m,s,f,d) IMPL_SEQFOR_FOR_GUIDE7_B(m, s, f, d,
#define IMPL_SEQFOR_FOR_GUIDE7_A_0(m,s,f,d) f(8, d) IMPL_SEQFOR_NULL(
#define IMPL_SEQFOR_FOR_GUIDE7_B(m,s,f,d,...) m(8, d, __VA_ARGS__) IMPL_SEQFOR_FOR_GUIDE7_A(m, s, f, s(8, d, __VA_ARGS__),
#define IMPL_SEQFOR_FOR_GUIDE_A(m,s,f,d,e) IMPL_SEQFOR_CAT(IMPL_SEQFOR_FOR_GUIDE_A_, e)(m, s, f, d)
#define IMPL_SEQFOR_FOR_GUIDE_A_(m,s,f,d) IMPL_SEQFOR_FOR_GUIDE_B(m, s, f, d,
#define IMPL_SEQFOR_FOR_GUIDE_A_0(m,s,f,d) f(0, d) IMPL_SEQFOR_NULL(
#define IMPL_SEQFOR_FOR_GUIDE_B(m,s,f,d,...) m(0, d, __VA_ARGS__) IMPL_SEQFOR_FOR_GUIDE_A(m, s, f, s(0, d, __VA_ARGS__),
#define IMPL_SEQFOR_IDENTITY(...) __VA_ARGS__
#define IMPL_SEQFOR_IDENTITY0(...) __VA_ARGS__
#define IMPL_SEQFOR_IDENTITY1(...) __VA_ARGS__
#define IMPL_SEQFOR_IDENTITY2(...) __VA_ARGS__
#define IMPL_SEQFOR_IDENTITY3(...) __VA_ARGS__
#define IMPL_SEQFOR_IDENTITY4(...) __VA_ARGS__
#define IMPL_SEQFOR_IDENTITY5(...) __VA_ARGS__
#define IMPL_SEQFOR_IDENTITY6(...) __VA_ARGS__
#define IMPL_SEQFOR_IDENTITY7(...) __VA_ARGS__
#define IMPL_SEQFOR_LPAREN (
#define IMPL_SEQFOR_NULL(...) 
#define IMPL_SEQFOR_STATE(n,d,...) d
#define IMPL_SEQFOR_TO_GUIDE_A(...) __VA_ARGS__)IMPL_SEQFOR_TO_GUIDE_B
#define IMPL_SEQFOR_TO_GUIDE_B(...) __VA_ARGS__)IMPL_SEQFOR_TO_GUIDE_A
#define MACRO_SEQUENCE_FOR_H_ 
#define SF_CAT(x,y) SF_CAT_(x, y)
#define SF_CAT_(x,y) x##y
#define SF_FOR_EACH(m,s,f,d,seq) IMPL_SEQFOR_FOR(m, s, f, d, IMPL_SEQFOR_TO_GUIDE_A IMPL_SEQFOR_ANNOTATE_SEQ_END(IMPL_SEQFOR_ANNOTATE_SEQ_A seq)) )
#define SF_FOR_EACH0(m,s,f,d,seq) IMPL_SEQFOR_FOR0(m, s, f, d, IMPL_SEQFOR_TO_GUIDE_A IMPL_SEQFOR_ANNOTATE_SEQ_END(IMPL_SEQFOR_ANNOTATE_SEQ_A seq)) )
#define SF_FOR_EACH1(m,s,f,d,seq) IMPL_SEQFOR_FOR1(m, s, f, d, IMPL_SEQFOR_TO_GUIDE_A IMPL_SEQFOR_ANNOTATE_SEQ_END(IMPL_SEQFOR_ANNOTATE_SEQ_A seq)) )
#define SF_FOR_EACH2(m,s,f,d,seq) IMPL_SEQFOR_FOR2(m, s, f, d, IMPL_SEQFOR_TO_GUIDE_A IMPL_SEQFOR_ANNOTATE_SEQ_END(IMPL_SEQFOR_ANNOTATE_SEQ_A seq)) )
#define SF_FOR_EACH3(m,s,f,d,seq) IMPL_SEQFOR_FOR3(m, s, f, d, IMPL_SEQFOR_TO_GUIDE_A IMPL_SEQFOR_ANNOTATE_SEQ_END(IMPL_SEQFOR_ANNOTATE_SEQ_A seq)) )
#define SF_FOR_EACH4(m,s,f,d,seq) IMPL_SEQFOR_FOR4(m, s, f, d, IMPL_SEQFOR_TO_GUIDE_A IMPL_SEQFOR_ANNOTATE_SEQ_END(IMPL_SEQFOR_ANNOTATE_SEQ_A seq)) )
#define SF_FOR_EACH5(m,s,f,d,seq) IMPL_SEQFOR_FOR5(m, s, f, d, IMPL_SEQFOR_TO_GUIDE_A IMPL_SEQFOR_ANNOTATE_SEQ_END(IMPL_SEQFOR_ANNOTATE_SEQ_A seq)) )
#define SF_FOR_EACH6(m,s,f,d,seq) IMPL_SEQFOR_FOR6(m, s, f, d, IMPL_SEQFOR_TO_GUIDE_A IMPL_SEQFOR_ANNOTATE_SEQ_END(IMPL_SEQFOR_ANNOTATE_SEQ_A seq)) )
#define SF_FOR_EACH7(m,s,f,d,seq) IMPL_SEQFOR_FOR7(m, s, f, d, IMPL_SEQFOR_TO_GUIDE_A IMPL_SEQFOR_ANNOTATE_SEQ_END(IMPL_SEQFOR_ANNOTATE_SEQ_A seq)) )
#define SF_MAX_DEPTH 8
#define SF_NULL(...) 
#define SF_STATE(...) IMPL_SEQFOR_STATE(__VA_ARGS__,)
#define _P_(...) )(DETAIL_EM_CGBITS_LPAREN,__VA_ARGS__)(DETAIL_EM_CGBITS_RPAREN, // Can't use `EM_P`, must write this directly.
#define _1_ EM_1
#define _1_OPT_ EM_1_OPT
#define _2_ EM_2
#define _2_OPT_ EM_2_OPT
#define _3_ EM_3
#define _3_OPT_ EM_3_OPT
#define _4_ EM_4
#define _4_OPT_ EM_4_OPT
#define _5_ EM_5
#define _5_OPT_ EM_5_OPT
#define _6_ EM_6
#define _6_OPT_ EM_6_OPT
#define _7_ EM_7
#define _7_OPT_ EM_7_OPT
#define _8_ EM_8
#define _8_OPT_ EM_8_OPT

// ---------------------

#include <string>

#define MAKE_ENUM(E, elems) \
    enum class E { \
        EM_CODEGEN(elems,, _1_ MAYBE_INIT _P_(_2_OPT_),) \
    }; \
    std::string ToString(E e) \
    { \
        switch (e) { EM_CODEGEN(elems,, case E::EM_1: return EM_STR _P_(_1_);) } \
    }
#define MAYBE_INIT(...) __VA_OPT__(= __VA_ARGS__)

MAKE_ENUM( E,
    (a,10)
    (b)
    (c,30)
)