Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/phoenix/core/detail/expression.hpp')
| -rw-r--r-- | 3rdParty/Boost/src/boost/phoenix/core/detail/expression.hpp | 409 |
1 files changed, 409 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/phoenix/core/detail/expression.hpp b/3rdParty/Boost/src/boost/phoenix/core/detail/expression.hpp new file mode 100644 index 0000000..7b239b1 --- /dev/null +++ b/3rdParty/Boost/src/boost/phoenix/core/detail/expression.hpp @@ -0,0 +1,409 @@ +/*============================================================================= + 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))> \ + 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 \ + inline 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)) \ + ); \ + } \ +/**/ + +#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) \ + ) \ + ) \ +/**/ + +#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 \ + ) \ + > \ + > \ + {}; \ +/**/ + +#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)) \ + ) \ +/**/ + +#define BOOST_PHOENIX_DEFINE_EXPRESSION_MAKE_EXPRESSION_VARARG_R(Z, N, NAME) \ + template <BOOST_PHOENIX_typename_A(N)> \ + typename \ + result_of:: BOOST_PP_CAT(make_, NAME)< \ + BOOST_PHOENIX_A(N) \ + >::type \ + inline 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)) \ + ) \ +/**/ + +#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 |