Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/proto/proto_fwd.hpp')
| -rw-r--r-- | 3rdParty/Boost/src/boost/proto/proto_fwd.hpp | 886 |
1 files changed, 886 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/proto/proto_fwd.hpp b/3rdParty/Boost/src/boost/proto/proto_fwd.hpp new file mode 100644 index 0000000..5547e77 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/proto_fwd.hpp @@ -0,0 +1,886 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file proto_fwd.hpp +/// Forward declarations of all of proto's public types and functions. +// +// Copyright 2008 Eric Niebler. 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_PROTO_FWD_HPP_EAN_04_01_2005 +#define BOOST_PROTO_FWD_HPP_EAN_04_01_2005 + +#include <cstddef> +#include <climits> +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/preprocessor/punctuation/comma.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> +#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> +#include <boost/preprocessor/repetition/repeat_from_to.hpp> +#include <boost/ref.hpp> +#include <boost/mpl/long.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/mpl/aux_/config/ttp.hpp> +#include <boost/utility/result_of.hpp> + +#ifndef BOOST_PROTO_MAX_ARITY +# define BOOST_PROTO_MAX_ARITY 10 +#endif + +#ifndef BOOST_PROTO_MAX_LOGICAL_ARITY +# define BOOST_PROTO_MAX_LOGICAL_ARITY 10 +#endif + +#ifndef BOOST_PROTO_MAX_FUNCTION_CALL_ARITY +# define BOOST_PROTO_MAX_FUNCTION_CALL_ARITY BOOST_PROTO_MAX_ARITY +#endif + +#if BOOST_PROTO_MAX_ARITY < 3 +# error BOOST_PROTO_MAX_ARITY must be at least 3 +#endif + +#if BOOST_PROTO_MAX_FUNCTION_CALL_ARITY > BOOST_PROTO_MAX_ARITY +# error BOOST_PROTO_MAX_FUNCTION_CALL_ARITY cannot be larger than BOOST_PROTO_MAX_ARITY +#endif + +#ifndef BOOST_PROTO_DONT_USE_PREPROCESSED_FILES + #if 10 < BOOST_PROTO_MAX_ARITY || \ + 10 < BOOST_PROTO_MAX_LOGICAL_ARITY || \ + 10 < BOOST_PROTO_MAX_FUNCTION_CALL_ARITY + #define BOOST_PROTO_DONT_USE_PREPROCESSED_FILES + #endif +#endif + +#ifndef BOOST_PROTO_BROKEN_CONST_OVERLOADS +# if BOOST_WORKAROUND(__GNUC__, == 3) \ + || BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(310)) +# define BOOST_PROTO_BROKEN_CONST_OVERLOADS +# endif +#endif + +#ifndef BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS +# if BOOST_WORKAROUND(__GNUC__, == 3) \ + || BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(310)) +# define BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS +# endif +#endif + +#ifdef BOOST_PROTO_BROKEN_CONST_OVERLOADS +# include <boost/utility/enable_if.hpp> +# include <boost/type_traits/is_const.hpp> +# define BOOST_PROTO_DISABLE_IF_IS_CONST(T)\ + , typename boost::disable_if_c<boost::is_const<T>::value, boost::proto::detail::undefined>::type * = 0 +#else +# define BOOST_PROTO_DISABLE_IF_IS_CONST(T) +#endif + +#ifdef BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS +# include <boost/utility/enable_if.hpp> +# include <boost/type_traits/is_function.hpp> +# define BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)\ + , typename boost::disable_if_c<boost::is_function<T>::value, boost::proto::detail::undefined>::type * = 0 +#else +# define BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T) +#endif + +#ifndef BOOST_PROTO_BROKEN_PTS +# if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) +# define BOOST_PROTO_BROKEN_PTS +# endif +#endif + +#ifdef BOOST_NO_DECLTYPE_N3276 +# // Proto can only use the decltype-based result_of if N3276 has been +# // implemented by the compiler. +# // See http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2011/n3276.pdf +# ifndef BOOST_PROTO_USE_NORMAL_RESULT_OF +# define BOOST_PROTO_USE_NORMAL_RESULT_OF +# endif +#endif + +// Unless compiler support is there, use tr1_result_of instead of +// result_of to avoid the problems addressed by N3276. +#ifdef BOOST_PROTO_USE_NORMAL_RESULT_OF +# define BOOST_PROTO_RESULT_OF boost::result_of +#else +# define BOOST_PROTO_RESULT_OF boost::tr1_result_of +#endif + +// If we're using the decltype-based result_of, we need to be a bit +// stricter about the return types of some functions. +#if defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_PROTO_USE_NORMAL_RESULT_OF) +# define BOOST_PROTO_STRICT_RESULT_OF +# define BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(X, Y) X +#else +# define BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(X, Y) Y +#endif + +#ifdef BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING +# define BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING +#endif + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# define BOOST_PROTO_DISABLE_MSVC_C4522 __pragma(warning(disable : 4522)) // 'class' : multiple assignment operators specified +# define BOOST_PROTO_DISABLE_MSVC_C4714 __pragma(warning(disable : 4714)) // function 'xxx' marked as __forceinline not inlined +#else +# define BOOST_PROTO_DISABLE_MSVC_C4522 +# define BOOST_PROTO_DISABLE_MSVC_C4714 +#endif + +namespace boost { namespace proto +{ + namespace detail + { + typedef char yes_type; + typedef char (&no_type)[2]; + + template<int N> + struct sized_type + { + typedef char (&type)[N]; + }; + + struct dont_care; + struct undefined; // leave this undefined + struct not_a_valid_type; + + struct private_type_ + { + private_type_ operator ,(int) const; + }; + + template<typename T> + struct uncvref + { + typedef T type; + }; + + template<typename T> + struct uncvref<T const> + { + typedef T type; + }; + + template<typename T> + struct uncvref<T &> + { + typedef T type; + }; + + template<typename T> + struct uncvref<T const &> + { + typedef T type; + }; + + template<typename T, std::size_t N> + struct uncvref<T const[N]> + { + typedef T type[N]; + }; + + template<typename T, std::size_t N> + struct uncvref<T (&)[N]> + { + typedef T type[N]; + }; + + template<typename T, std::size_t N> + struct uncvref<T const (&)[N]> + { + typedef T type[N]; + }; + + struct ignore + { + ignore() + {} + + template<typename T> + ignore(T const &) + {} + }; + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_UNCVREF(X) \ + typename boost::proto::detail::uncvref<X>::type \ + /**/ + + struct _default; + + struct not_a_domain; + struct not_a_grammar; + struct not_a_generator; + + template<typename T, typename Void = void> + struct is_transform_; + + template<typename T, typename Void = void> + struct is_aggregate_; + + template<typename Expr> + struct flat_view; + } + + typedef detail::ignore const ignore; + + namespace argsns_ + { + template<typename Arg0> + struct term; + + #define M0(Z, N, DATA) \ + template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename Arg)> struct BOOST_PP_CAT(list, N); \ + /**/ + BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M0, ~) + #undef M0 + } + + using namespace argsns_; + + /////////////////////////////////////////////////////////////////////////////// + // Operator tags + namespace tagns_ + { + namespace tag + { + struct terminal; + struct unary_plus; + struct negate; + struct dereference; + struct complement; + struct address_of; + struct logical_not; + struct pre_inc; + struct pre_dec; + struct post_inc; + struct post_dec; + + struct shift_left; + struct shift_right; + struct multiplies; + struct divides; + struct modulus; + struct plus; + struct minus; + struct less; + struct greater; + struct less_equal; + struct greater_equal; + struct equal_to; + struct not_equal_to; + struct logical_or; + struct logical_and; + struct bitwise_and; + struct bitwise_or; + struct bitwise_xor; + struct comma; + struct mem_ptr; + + struct assign; + struct shift_left_assign; + struct shift_right_assign; + struct multiplies_assign; + struct divides_assign; + struct modulus_assign; + struct plus_assign; + struct minus_assign; + struct bitwise_and_assign; + struct bitwise_or_assign; + struct bitwise_xor_assign; + struct subscript; + struct member; + struct if_else_; + struct function; + + // Fusion tags + template<typename Tag, typename Domain> struct proto_expr; + template<typename Tag, typename Domain> struct proto_expr_iterator; + template<typename Tag, typename Domain> struct proto_flat_view; + } + } + + using namespace tagns_; + + template<typename Expr> + struct tag_of; + + //////////////////////////////////////////////////////////////////////////////////////////////// + struct _; + + //////////////////////////////////////////////////////////////////////////////////////////////// + struct default_generator; + + struct basic_default_generator; + + template<template<typename> class Extends> + struct generator; + + template<template<typename> class Extends> + struct pod_generator; + + struct by_value_generator; + + template<typename First, typename Second> + struct compose_generators; + + template<typename Generator, typename Void = void> + struct wants_basic_expr; + + template<typename Generator> + struct use_basic_expr; + + //////////////////////////////////////////////////////////////////////////////////////////////// + namespace domainns_ + { + typedef detail::not_a_domain no_super_domain; + + template< + typename Generator = default_generator + , typename Grammar = proto::_ + , typename Super = no_super_domain + > + struct domain; + + struct default_domain; + + struct basic_default_domain; + + struct deduce_domain; + + template<typename Domain, typename Tag, typename Args, bool WantsBasicExpr = wants_basic_expr<typename Domain::proto_generator>::value> + struct base_expr; + } + + using namespace domainns_; + + //////////////////////////////////////////////////////////////////////////////////////////////// + namespace exprns_ + { + template<typename Tag, typename Args, long Arity = Args::arity> + struct basic_expr; + + template<typename Tag, typename Args, long Arity = Args::arity> + struct expr; + + template< + typename Expr + , typename Derived + , typename Domain = default_domain + , long Arity = Expr::proto_arity_c + > + struct extends; + + template<typename This, typename Fun, typename Domain> + struct virtual_member; + + struct is_proto_expr; + } + //////////////////////////////////////////////////////////////////////////////////////////////// + + using exprns_::expr; + using exprns_::basic_expr; + using exprns_::extends; + using exprns_::is_proto_expr; + + template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G, void)> + struct or_; + + template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G, void)> + struct and_; + + template<typename Grammar> + struct not_; + + template<typename Condition, typename Then = _, typename Else = not_<_> > + struct if_; + + template<typename Cases, typename Transform = tag_of<_>()> + struct switch_; + + template<typename T> + struct exact; + + template<typename T> + struct convertible_to; + + template<typename Grammar> + struct vararg; + + struct pack; + + // Boost bug https://svn.boost.org/trac/boost/ticket/4602 + //int const N = INT_MAX; + int const N = (INT_MAX >> 10); + + namespace context + { + struct null_context; + + template<typename Expr, typename Context, long Arity = Expr::proto_arity_c> + struct null_eval; + + struct default_context; + + template<typename Expr, typename Context, typename Tag = typename Expr::proto_tag, long Arity = Expr::proto_arity_c> + struct default_eval; + + template<typename Derived, typename DefaultCtx = default_context> + struct callable_context; + + template<typename Expr, typename Context, long Arity = Expr::proto_arity_c> + struct callable_eval; + } + + using context::null_context; + using context::null_eval; + using context::default_context; + using context::default_eval; + using context::callable_context; + using context::callable_eval; + + namespace utility + { + template<typename T, typename Domain = default_domain> + struct literal; + } + + using utility::literal; + + namespace result_of + { + template<typename T, typename Domain = default_domain> + struct as_expr; + + template<typename T, typename Domain = default_domain> + struct as_child; + + template<typename Expr, typename N = mpl::long_<0> > + struct child; + + template<typename Expr, long N> + struct child_c; + + template<typename Expr> + struct left; + + template<typename Expr> + struct right; + + template<typename Expr> + struct deep_copy; + + template<typename Expr, typename Context> + struct eval; + + template< + typename Tag + , typename DomainOrA0 + BOOST_PP_ENUM_TRAILING_BINARY_PARAMS( + BOOST_PROTO_MAX_ARITY + , typename A + , = void BOOST_PP_INTERCEPT + ) + , typename Void = void + > + struct make_expr; + + template<typename Tag, typename DomainOrSequence, typename SequenceOrVoid = void, typename Void = void> + struct unpack_expr; + + template<typename T> + struct as_env; + + template<typename Env, typename Tag> + struct has_env_var; + + template<typename Env, typename Tag> + struct env_var; + } + + template<typename T, typename Void = void> + struct is_expr; + + template<typename T, typename Void = void> + struct is_domain; + + template<typename SubDomain, typename SuperDomain> + struct is_sub_domain_of; + + template<typename T, typename Void = void> + struct is_env; + + template<typename Expr> + struct arity_of; + + template<typename T, typename Void = void> + struct domain_of; + + template<typename Expr, typename Grammar> + struct matches; + + // Generic expression metafunctions and + // grammar elements + template<typename Tag, typename Arg> + struct unary_expr; + + template<typename Tag, typename Left, typename Right> + struct binary_expr; + + template<typename Tag, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A, void)> + struct nary_expr; + + // Specific expression metafunctions and + // grammar elements, for convenience + template<typename T> struct terminal; + template<typename T> struct unary_plus; + template<typename T> struct negate; + template<typename T> struct dereference; + template<typename T> struct complement; + template<typename T> struct address_of; + template<typename T> struct logical_not; + template<typename T> struct pre_inc; + template<typename T> struct pre_dec; + template<typename T> struct post_inc; + template<typename T> struct post_dec; + + template<typename T, typename U> struct shift_left; + template<typename T, typename U> struct shift_right; + template<typename T, typename U> struct multiplies; + template<typename T, typename U> struct divides; + template<typename T, typename U> struct modulus; + template<typename T, typename U> struct plus; + template<typename T, typename U> struct minus; + template<typename T, typename U> struct less; + template<typename T, typename U> struct greater; + template<typename T, typename U> struct less_equal; + template<typename T, typename U> struct greater_equal; + template<typename T, typename U> struct equal_to; + template<typename T, typename U> struct not_equal_to; + template<typename T, typename U> struct logical_or; + template<typename T, typename U> struct logical_and; + template<typename T, typename U> struct bitwise_and; + template<typename T, typename U> struct bitwise_or; + template<typename T, typename U> struct bitwise_xor; + template<typename T, typename U> struct comma; + template<typename T, typename U> struct mem_ptr; + + template<typename T, typename U> struct assign; + template<typename T, typename U> struct shift_left_assign; + template<typename T, typename U> struct shift_right_assign; + template<typename T, typename U> struct multiplies_assign; + template<typename T, typename U> struct divides_assign; + template<typename T, typename U> struct modulus_assign; + template<typename T, typename U> struct plus_assign; + template<typename T, typename U> struct minus_assign; + template<typename T, typename U> struct bitwise_and_assign; + template<typename T, typename U> struct bitwise_or_assign; + template<typename T, typename U> struct bitwise_xor_assign; + template<typename T, typename U> struct subscript; + template<typename T, typename U> struct member; + template<typename T, typename U, typename V> struct if_else_; + + template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A, void)> + struct function; + + namespace functional + { + struct left; + struct right; + struct eval; + struct deep_copy; + + template<typename Domain = default_domain> + struct as_expr; + + template<typename Domain = default_domain> + struct as_child; + + template<typename N = mpl::long_<0> > + struct child; + + template<long N> + struct child_c; + + struct as_env; + + template<typename Tag> + struct has_env_var; + + template<typename Tag> + struct env_var; + + template<typename Tag, typename Domain = deduce_domain> + struct make_expr; + + template<typename Tag, typename Domain = deduce_domain> + struct unpack_expr; + + typedef make_expr<tag::terminal> make_terminal; + typedef make_expr<tag::unary_plus> make_unary_plus; + typedef make_expr<tag::negate> make_negate; + typedef make_expr<tag::dereference> make_dereference; + typedef make_expr<tag::complement> make_complement; + typedef make_expr<tag::address_of> make_address_of; + typedef make_expr<tag::logical_not> make_logical_not; + typedef make_expr<tag::pre_inc> make_pre_inc; + typedef make_expr<tag::pre_dec> make_pre_dec; + typedef make_expr<tag::post_inc> make_post_inc; + typedef make_expr<tag::post_dec> make_post_dec; + typedef make_expr<tag::shift_left> make_shift_left; + typedef make_expr<tag::shift_right> make_shift_right; + typedef make_expr<tag::multiplies> make_multiplies; + typedef make_expr<tag::divides> make_divides; + typedef make_expr<tag::modulus> make_modulus; + typedef make_expr<tag::plus> make_plus; + typedef make_expr<tag::minus> make_minus; + typedef make_expr<tag::less> make_less; + typedef make_expr<tag::greater> make_greater; + typedef make_expr<tag::less_equal> make_less_equal; + typedef make_expr<tag::greater_equal> make_greater_equal; + typedef make_expr<tag::equal_to> make_equal_to; + typedef make_expr<tag::not_equal_to> make_not_equal_to; + typedef make_expr<tag::logical_or> make_logical_or; + typedef make_expr<tag::logical_and> make_logical_and; + typedef make_expr<tag::bitwise_and> make_bitwise_and; + typedef make_expr<tag::bitwise_or> make_bitwise_or; + typedef make_expr<tag::bitwise_xor> make_bitwise_xor; + typedef make_expr<tag::comma> make_comma; + typedef make_expr<tag::mem_ptr> make_mem_ptr; + typedef make_expr<tag::assign> make_assign; + typedef make_expr<tag::shift_left_assign> make_shift_left_assign; + typedef make_expr<tag::shift_right_assign> make_shift_right_assign; + typedef make_expr<tag::multiplies_assign> make_multiplies_assign; + typedef make_expr<tag::divides_assign> make_divides_assign; + typedef make_expr<tag::modulus_assign> make_modulus_assign; + typedef make_expr<tag::plus_assign> make_plus_assign; + typedef make_expr<tag::minus_assign> make_minus_assign; + typedef make_expr<tag::bitwise_and_assign> make_bitwise_and_assign; + typedef make_expr<tag::bitwise_or_assign> make_bitwise_or_assign; + typedef make_expr<tag::bitwise_xor_assign> make_bitwise_xor_assign; + typedef make_expr<tag::subscript> make_subscript; + typedef make_expr<tag::if_else_> make_if_else; + typedef make_expr<tag::function> make_function; + + struct flatten; + struct make_pair; + struct first; + struct second; + struct at; + struct pop_front; + struct push_front; + struct pop_back; + struct push_back; + struct reverse; + } + + typedef functional::flatten _flatten; + typedef functional::make_pair _make_pair; + typedef functional::first _first; + typedef functional::second _second; + typedef functional::pop_front _at; + typedef functional::pop_front _pop_front; + typedef functional::push_front _push_front; + typedef functional::pop_back _pop_back; + typedef functional::push_back _push_back; + typedef functional::reverse _reverse; + typedef functional::eval _eval; + struct _deep_copy; + + typedef functional::make_expr<tag::terminal> _make_terminal; + typedef functional::make_expr<tag::unary_plus> _make_unary_plus; + typedef functional::make_expr<tag::negate> _make_negate; + typedef functional::make_expr<tag::dereference> _make_dereference; + typedef functional::make_expr<tag::complement> _make_complement; + typedef functional::make_expr<tag::address_of> _make_address_of; + typedef functional::make_expr<tag::logical_not> _make_logical_not; + typedef functional::make_expr<tag::pre_inc> _make_pre_inc; + typedef functional::make_expr<tag::pre_dec> _make_pre_dec; + typedef functional::make_expr<tag::post_inc> _make_post_inc; + typedef functional::make_expr<tag::post_dec> _make_post_dec; + typedef functional::make_expr<tag::shift_left> _make_shift_left; + typedef functional::make_expr<tag::shift_right> _make_shift_right; + typedef functional::make_expr<tag::multiplies> _make_multiplies; + typedef functional::make_expr<tag::divides> _make_divides; + typedef functional::make_expr<tag::modulus> _make_modulus; + typedef functional::make_expr<tag::plus> _make_plus; + typedef functional::make_expr<tag::minus> _make_minus; + typedef functional::make_expr<tag::less> _make_less; + typedef functional::make_expr<tag::greater> _make_greater; + typedef functional::make_expr<tag::less_equal> _make_less_equal; + typedef functional::make_expr<tag::greater_equal> _make_greater_equal; + typedef functional::make_expr<tag::equal_to> _make_equal_to; + typedef functional::make_expr<tag::not_equal_to> _make_not_equal_to; + typedef functional::make_expr<tag::logical_or> _make_logical_or; + typedef functional::make_expr<tag::logical_and> _make_logical_and; + typedef functional::make_expr<tag::bitwise_and> _make_bitwise_and; + typedef functional::make_expr<tag::bitwise_or> _make_bitwise_or; + typedef functional::make_expr<tag::bitwise_xor> _make_bitwise_xor; + typedef functional::make_expr<tag::comma> _make_comma; + typedef functional::make_expr<tag::mem_ptr> _make_mem_ptr; + typedef functional::make_expr<tag::assign> _make_assign; + typedef functional::make_expr<tag::shift_left_assign> _make_shift_left_assign; + typedef functional::make_expr<tag::shift_right_assign> _make_shift_right_assign; + typedef functional::make_expr<tag::multiplies_assign> _make_multiplies_assign; + typedef functional::make_expr<tag::divides_assign> _make_divides_assign; + typedef functional::make_expr<tag::modulus_assign> _make_modulus_assign; + typedef functional::make_expr<tag::plus_assign> _make_plus_assign; + typedef functional::make_expr<tag::minus_assign> _make_minus_assign; + typedef functional::make_expr<tag::bitwise_and_assign> _make_bitwise_and_assign; + typedef functional::make_expr<tag::bitwise_or_assign> _make_bitwise_or_assign; + typedef functional::make_expr<tag::bitwise_xor_assign> _make_bitwise_xor_assign; + typedef functional::make_expr<tag::subscript> _make_subscript; + typedef functional::make_expr<tag::if_else_> _make_if_else; + typedef functional::make_expr<tag::function> _make_function; + + template<typename T> + struct is_callable; + + template<typename T> + struct is_transform; + + template<typename T> + struct is_aggregate; + + #define BOOST_PROTO_UNEXPR() typedef int proto_is_expr_; + #define BOOST_PROTO_CALLABLE() typedef void proto_is_callable_; + #define BOOST_PROTO_AGGREGATE() typedef void proto_is_aggregate_; + #define BOOST_PROTO_USE_BASIC_EXPR() typedef void proto_use_basic_expr_; + + struct callable + { + BOOST_PROTO_CALLABLE() + }; + + namespace envns_ + { + struct key_not_found; + + struct empty_env; + + typedef int empty_state; + + template<typename Tag, typename Value, typename Base = empty_env> + struct env; + + struct data_type; + + struct transforms_type; + } + + using envns_::key_not_found; + using envns_::empty_env; + using envns_::empty_state; + using envns_::env; + using envns_::data_type; + using envns_::transforms_type; + + struct external_transform; + + template<typename PrimitiveTransform = void, typename X = void> + struct transform; + + template<typename Grammar, typename Fun = Grammar> + struct when; + + template<typename Fun> + struct otherwise; + + template<typename Fun> + struct call; + + template<typename Fun> + struct make; + + template<typename PrimitiveTransform> + struct protect; + + template<typename T> + struct noinvoke; + + template<typename Fun> + struct lazy; + + template<typename Sequence, typename State, typename Fun> + struct fold; + + template<typename Sequence, typename State, typename Fun> + struct reverse_fold; + + // Q: can we replace fold_tree with fold<flatten(_), state, fun> ? + // A: once segmented Fusion works well. + template<typename Sequence, typename State, typename Fun> + struct fold_tree; + + template<typename Sequence, typename State, typename Fun> + struct reverse_fold_tree; + + template<typename Grammar, typename Domain = deduce_domain> + struct pass_through; + + template<typename Grammar = detail::_default> + struct _default; + + struct _expr; + struct _state; + struct _data; + + struct _value; + + struct _void; + + template<typename T, T I> + struct integral_c; + + template<char I> + struct char_; + + template<int I> + struct int_; + + template<long I> + struct long_; + + template<std::size_t I> + struct size_t; + + template<int I> + struct _child_c; + + typedef _child_c<0> _child0; + typedef _child_c<1> _child1; + typedef _child0 _child; + typedef _child0 _left; + typedef _child1 _right; + + // _child2, _child3, _child4, ... + #define M0(Z, N, DATA) typedef _child_c<N> BOOST_PP_CAT(_child, N); + BOOST_PP_REPEAT_FROM_TO( + 2 + , BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY) + , M0 + , ~ + ) + #undef M0 + + struct _byref; + struct _byval; + + template<typename Tag> + struct _env_var; + + struct _env; + + template<typename T> + struct is_extension; + + namespace exops = exprns_; + +}} // namespace boost::proto + +#endif |