chris/js8call
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
62042cfa33
js8call/.svn/pristine/b1/b1dea90f8a6644af5f0c8568c573a7a95d0eab31.svn-base

887 lines
29 KiB
Plaintext
Raw Normal View History

Initial Commit
2018-02-08 21:28:33 -05:00
///////////////////////////////////////////////////////////////////////////////
/// \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_CXX11_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)
# 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
Reference in New Issue Copy Permalink