123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461 |
- /*=============================================================================
- Copyright (c) 2010 Thomas Heller
- Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- ==============================================================================*/
- #ifndef BOOST_PHOENIX_CORE_DETAIL_EXPRESSION_HPP
- #define BOOST_PHOENIX_CORE_DETAIL_EXPRESSION_HPP
- #include <boost/preprocessor/empty.hpp>
- #include <boost/preprocessor/arithmetic/add.hpp>
- #include <boost/preprocessor/arithmetic/dec.hpp>
- #include <boost/preprocessor/comma_if.hpp>
- #include <boost/preprocessor/comparison/equal.hpp>
- #include <boost/preprocessor/seq/size.hpp>
- #include <boost/preprocessor/seq/enum.hpp>
- #include <boost/preprocessor/seq/for_each.hpp>
- #include <boost/preprocessor/seq/pop_back.hpp>
- #include <boost/preprocessor/seq/reverse.hpp>
- #include <boost/preprocessor/tuple/elem.hpp>
- #include <boost/preprocessor/enum_params.hpp>
- #include <boost/preprocessor/repeat_from_to.hpp>
- #define BOOST_PHOENIX_DEFINE_EXPRESSION(NAME_SEQ, SEQ) \
- BOOST_PHOENIX_DEFINE_EXPRESSION_BASE( \
- NAME_SEQ \
- , SEQ \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_EXPRESSION_DEFAULT \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_RULE_DEFAULT \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_RESULT_OF_MAKE_DEFAULT \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_MAKE_EXPRESSION_DEFAULT \
- , _ \
- ) \
- /**/
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_VARARG(NAME_SEQ, GRAMMAR_SEQ, LIMIT) \
- BOOST_PHOENIX_DEFINE_EXPRESSION_BASE( \
- NAME_SEQ \
- , GRAMMAR_SEQ \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_EXPRESSION_VARARG \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_RULE_VARARG \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_RESULT_OF_MAKE_VARARG \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_MAKE_EXPRESSION_VARARG \
- , LIMIT \
- ) \
- /**/
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_EXT(ACTOR, NAME_SEQ, GRAMMAR_SEQ) \
- BOOST_PHOENIX_DEFINE_EXPRESSION_BASE( \
- NAME_SEQ \
- , GRAMMAR_SEQ \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_EXPRESSION_EXT \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_RULE_DEFAULT \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_RESULT_OF_MAKE_DEFAULT \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_MAKE_EXPRESSION_DEFAULT \
- , ACTOR \
- ) \
- /**/
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_EXT_VARARG(ACTOR, NAME, GRAMMAR, LIMIT) \
- BOOST_PHOENIX_DEFINE_EXPRESSION_BASE( \
- NAME_SEQ \
- , GRAMMAR_SEQ \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_EXPRESSION_VARARG_EXT \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_RULE_VARARG \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_RESULT_OF_MAKE_VARARG \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_MAKE_EXPRESSION_VARARG \
- , ACTOR \
- ) \
- /**/
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_NAMESPACE(R, D, E) \
- namespace E { \
- /**/
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_NAMESPACE_END(R, D, E) \
- } \
- /**/
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_NS(R, D, E) \
- E :: \
- /**/
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_BASE(NAME_SEQ, GRAMMAR_SEQ, EXPRESSION, RULE, RESULT_OF_MAKE, MAKE_EXPRESSION, DATA) \
- BOOST_PP_SEQ_FOR_EACH( \
- BOOST_PHOENIX_DEFINE_EXPRESSION_NAMESPACE \
- , _ \
- , BOOST_PP_SEQ_POP_BACK(NAME_SEQ) \
- ) \
- namespace tag \
- { \
- struct BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) {}; \
- template <typename Ostream> \
- inline Ostream &operator<<( \
- Ostream & os \
- , BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ))) \
- { \
- os << BOOST_PP_STRINGIZE( \
- BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- ); \
- return os; \
- } \
- } \
- namespace expression \
- { \
- EXPRESSION(NAME_SEQ, GRAMMAR_SEQ, DATA) \
- } \
- namespace rule \
- { \
- RULE(NAME_SEQ, GRAMMAR_SEQ, DATA) \
- } \
- namespace functional \
- { \
- typedef \
- boost::proto::functional::make_expr< \
- tag:: BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- > \
- BOOST_PP_CAT( \
- make_ \
- , BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- ); \
- } \
- namespace result_of \
- { \
- RESULT_OF_MAKE(NAME_SEQ, GRAMMAR_SEQ, DATA) \
- } \
- MAKE_EXPRESSION(NAME_SEQ, GRAMMAR_SEQ, DATA) \
- \
- BOOST_PP_SEQ_FOR_EACH( \
- BOOST_PHOENIX_DEFINE_EXPRESSION_NAMESPACE_END \
- , _ \
- , BOOST_PP_SEQ_POP_BACK(NAME_SEQ) \
- ) \
- namespace boost { namespace phoenix \
- { \
- template <typename Dummy> \
- struct meta_grammar::case_< \
- :: BOOST_PP_SEQ_FOR_EACH( \
- BOOST_PHOENIX_DEFINE_EXPRESSION_NS \
- , _ \
- , BOOST_PP_SEQ_POP_BACK(NAME_SEQ) \
- ) tag:: BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- , Dummy \
- > \
- : enable_rule< \
- :: BOOST_PP_SEQ_FOR_EACH( \
- BOOST_PHOENIX_DEFINE_EXPRESSION_NS \
- , _ \
- , BOOST_PP_SEQ_POP_BACK(NAME_SEQ) \
- ) rule:: BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- , Dummy \
- > \
- {}; \
- } } \
- /**/
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_EXPRESSION_DEFAULT(NAME_SEQ, GRAMMAR_SEQ, D) \
- template <BOOST_PHOENIX_typename_A(BOOST_PP_SEQ_SIZE(GRAMMAR_SEQ))> \
- struct BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- : boost::phoenix::expr< \
- :: BOOST_PP_SEQ_FOR_EACH( \
- BOOST_PHOENIX_DEFINE_EXPRESSION_NS \
- , _ \
- , BOOST_PP_SEQ_POP_BACK(NAME_SEQ) \
- ) tag:: BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- , BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(GRAMMAR_SEQ), A)> \
- {}; \
- /**/
-
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_RULE_DEFAULT(NAME_SEQ, GRAMMAR_SEQ, D) \
- struct BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- : expression:: BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- <BOOST_PP_SEQ_ENUM(GRAMMAR_SEQ)> \
- {}; \
- /**/
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_RESULT_OF_MAKE_DEFAULT(NAME_SEQ, GRAMMAR_SEQ, D) \
- template <BOOST_PHOENIX_typename_A(BOOST_PP_SEQ_SIZE(GRAMMAR_SEQ))> \
- struct BOOST_PP_CAT(make_, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ))) \
- : boost::result_of< \
- functional:: \
- BOOST_PP_CAT( \
- make_ \
- , BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- )(BOOST_PHOENIX_A(BOOST_PP_SEQ_SIZE(GRAMMAR_SEQ))) \
- > \
- {}; \
- /**/
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_MAKE_EXPRESSION_DEFAULT(NAME_SEQ, GRAMMAR_SEQ, D) \
- template <BOOST_PHOENIX_typename_A(BOOST_PP_SEQ_SIZE(GRAMMAR_SEQ))> \
- inline \
- typename \
- result_of::BOOST_PP_CAT( \
- make_ \
- , BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- )< \
- BOOST_PHOENIX_A(BOOST_PP_SEQ_SIZE(GRAMMAR_SEQ)) \
- >::type const \
- BOOST_PP_CAT( \
- make_ \
- , BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- )( \
- BOOST_PHOENIX_A_const_ref_a(BOOST_PP_SEQ_SIZE(GRAMMAR_SEQ)) \
- ) \
- { \
- return \
- functional::BOOST_PP_CAT( \
- make_ \
- , BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- )()( \
- BOOST_PHOENIX_a(BOOST_PP_SEQ_SIZE(GRAMMAR_SEQ)) \
- ); \
- } \
- /**/
- #ifndef BOOST_PHOENIX_NO_VARIADIC_EXPRESSION
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_EXPRESSION_VARARG(NAME_SEQ, _G, _L) \
- template <typename A0, typename... A> \
- struct BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- : boost::phoenix::expr< \
- tag:: BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- , A0, A... \
- > \
- {}; \
- /**/
- #else // BOOST_PHOENIX_NO_VARIADIC_EXPRESSION
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_VARARG_R(_, N, NAME) \
- template < \
- BOOST_PHOENIX_typename_A( \
- BOOST_PP_ADD( \
- N \
- , BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_ELEM(2, 1, NAME)) \
- ) \
- ) \
- > \
- struct BOOST_PP_TUPLE_ELEM(2, 0, NAME)< \
- BOOST_PHOENIX_A( \
- BOOST_PP_ADD(N, BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_ELEM(2, 1, NAME))) \
- ) \
- > \
- : boost::phoenix::expr< \
- tag:: BOOST_PP_TUPLE_ELEM(2, 0, NAME) \
- , BOOST_PHOENIX_A( \
- BOOST_PP_ADD( \
- N \
- , BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_ELEM(2, 1, NAME)) \
- ) \
- ) \
- > \
- {}; \
- /**/
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_EXPRESSION_VARARG(NAME_SEQ, GRAMMAR_SEQ, LIMIT) \
- template < \
- BOOST_PHOENIX_typename_A_void( \
- BOOST_PP_ADD( \
- LIMIT, BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(GRAMMAR_SEQ))) \
- ) \
- , typename Dummy = void \
- > \
- struct BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)); \
- \
- BOOST_PP_REPEAT_FROM_TO( \
- 1 \
- , BOOST_PP_ADD(LIMIT, BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(GRAMMAR_SEQ))) \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_VARARG_R \
- , ( \
- BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- , BOOST_PP_SEQ_POP_BACK(GRAMMAR_SEQ) \
- ) \
- ) \
- /**/
- #endif // BOOST_PHOENIX_NO_VARIADIC_EXPRESSION
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_RULE_VARARG(NAME_SEQ, GRAMMAR_SEQ, LIMIT) \
- struct BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- : expression:: BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) < \
- BOOST_PP_IF( \
- BOOST_PP_EQUAL(1, BOOST_PP_SEQ_SIZE(GRAMMAR_SEQ)) \
- , BOOST_PP_EMPTY \
- , BOOST_PP_IDENTITY( \
- BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_POP_BACK(GRAMMAR_SEQ)) \
- ) \
- )() \
- BOOST_PP_COMMA_IF(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(GRAMMAR_SEQ))) \
- boost::proto::vararg< \
- BOOST_PP_SEQ_ELEM( \
- BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(GRAMMAR_SEQ)) \
- , GRAMMAR_SEQ \
- ) \
- > \
- > \
- {}; \
- /**/
- #ifndef BOOST_PHOENIX_NO_VARIADIC_EXPRESSION
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_RESULT_OF_MAKE_VARARG(NAME_SEQ, _G, _L) \
- template <typename A0, typename... A> \
- struct BOOST_PP_CAT(make_, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ))) \
- : boost::result_of< \
- functional:: BOOST_PP_CAT(make_, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)))( \
- A0, A... \
- ) \
- > \
- {}; \
- /**/
- #else // BOOST_PHOENIX_NO_VARIADIC_EXPRESSION
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_RESULT_OF_MAKE_VARARG_R(Z, N, NAME) \
- template <BOOST_PHOENIX_typename_A(N)> \
- struct BOOST_PP_CAT(make_, NAME) <BOOST_PHOENIX_A(N)> \
- : boost::result_of< \
- functional:: BOOST_PP_CAT(make_, NAME)( \
- BOOST_PHOENIX_A(N) \
- ) \
- > \
- {}; \
- /**/
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_RESULT_OF_MAKE_VARARG(NAME_SEQ, GRAMMAR_SEQ, LIMIT) \
- template <BOOST_PHOENIX_typename_A_void(LIMIT), typename Dummy = void> \
- struct BOOST_PP_CAT( \
- make_ \
- , BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- ); \
- BOOST_PP_REPEAT_FROM_TO( \
- 1 \
- , LIMIT \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_RESULT_OF_MAKE_VARARG_R \
- , BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- ) \
- /**/
- #endif // BOOST_PHOENIX_NO_VARIADIC_EXPRESSION
- #ifndef BOOST_PHOENIX_NO_VARIADIC_EXPRESSION
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_MAKE_EXPRESSION_VARARG(NAME_SEQ, GRAMMAR_SEQ, LIMIT) \
- template <typename A0, typename... A> \
- inline \
- typename \
- result_of:: BOOST_PP_CAT(make_, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)))< \
- A0, A... \
- >::type \
- BOOST_PP_CAT(make_, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)))(A0 const& a0, A const&... a) \
- { \
- return functional::BOOST_PP_CAT(make_, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)))()(a0, a...); \
- } \
- /**/
- #else // BOOST_PHOENIX_NO_VARIADIC_EXPRESSION
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_MAKE_EXPRESSION_VARARG_R(Z, N, NAME) \
- template <BOOST_PHOENIX_typename_A(N)> \
- inline \
- typename \
- result_of:: BOOST_PP_CAT(make_, NAME)< \
- BOOST_PHOENIX_A(N) \
- >::type \
- BOOST_PP_CAT(make_, NAME)(BOOST_PHOENIX_A_const_ref_a(N)) \
- { \
- return functional::BOOST_PP_CAT(make_, NAME)()(BOOST_PHOENIX_a(N)); \
- } \
- /**/
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_MAKE_EXPRESSION_VARARG(NAME_SEQ, GRAMMAR_SEQ, LIMIT) \
- BOOST_PP_REPEAT_FROM_TO( \
- 1 \
- , LIMIT \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_MAKE_EXPRESSION_VARARG_R \
- , BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- ) \
- /**/
- #endif // BOOST_PHOENIX_NO_VARIADIC_EXPRESSION
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_EXPRESSION_EXT(NAME_SEQ, GRAMMAR_SEQ, ACTOR) \
- template <BOOST_PHOENIX_typename_A(BOOST_PP_SEQ_SIZE(GRAMMAR_SEQ))> \
- struct BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- : ::boost::phoenix::expr_ext< \
- ACTOR \
- , tag:: BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(NAME_SEQ)) \
- , BOOST_PHOENIX_A(BOOST_PP_SEQ_SIZE(GRAMMAR_SEQ))> \
- {}; \
- /**/
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_EXT_VARARG_R(_, N, NAME) \
- template < \
- BOOST_PHOENIX_typename_A( \
- BOOST_PP_ADD( \
- N \
- , BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_ELEM(3, 1, NAME)) \
- ) \
- ) \
- > \
- struct BOOST_PP_TUPLE_ELEM(3, 0, NAME)< \
- BOOST_PHOENIX_A( \
- BOOST_PP_ADD(N, BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_ELEM(3, 1, NAME))) \
- ) \
- > \
- : expr_ext< \
- BOOST_PP_TUPLE_ELEM(3, 2, NAME) \
- , tag:: BOOST_PP_TUPLE_ELEM(3, 0, NAME) \
- , BOOST_PHOENIX_A( \
- BOOST_PP_ADD( \
- N \
- , BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_ELEM(3, 1, NAME)) \
- ) \
- ) \
- > \
- {}; \
- /**/
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_EXRPESSION_VARARG_EXT(N, G, D) \
- template < \
- BOOST_PHOENIX_typename_A_void( \
- BOOST_PP_ADD(LIMIT, BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(G))) \
- ) \
- , typename Dummy = void \
- > \
- struct BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(N)); \
- \
- BOOST_PP_REPEAT_FROM_TO( \
- 1 \
- , BOOST_PP_ADD(LIMIT, BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(G))) \
- , BOOST_PHOENIX_DEFINE_EXPRESSION_EXT_VARARG_R \
- , ( \
- BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(N)) \
- , BOOST_PP_SEQ_POP_BACK(G) \
- , ACTOR \
- ) \
- ) \
- /**/
- #define BOOST_PHOENIX_DEFINE_EXPRESSION_RULE_VARARG_EXT(N, GRAMMAR, D) \
- struct BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(N)) \
- : expression:: BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REVERSE(N)) < \
- BOOST_PP_IF( \
- BOOST_PP_EQUAL(1, BOOST_PP_SEQ_SIZE(GRAMMAR)) \
- , BOOST_PP_EMPTY \
- , BOOST_PP_IDENTITY( \
- BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_POP_BACK(GRAMMAR)) \
- ) \
- )() \
- BOOST_PP_COMMA_IF(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(GRAMMAR))) \
- proto::vararg< \
- BOOST_PP_SEQ_ELEM( \
- BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(GRAMMAR)) \
- , GRAMMAR \
- ) \
- > \
- > \
- {}; \
- #endif
|