887 lines
29 KiB
Plaintext
887 lines
29 KiB
Plaintext
///////////////////////////////////////////////////////////////////////////////
|
|
/// \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
|