Contains definition of the proto::matches<> metafunction for determining if a given expression matches a given pattern. proto::transform<_> A wildcard grammar element that matches any expression, and a transform that returns the current expression unchanged. The wildcard type, proto::_, is a grammar element such that proto::matches<E, proto::_>::value is true for any expression type E. The wildcard can also be used as a stand-in for a template argument when matching terminals. For instance, the following is a grammar that will match any std::complex<> terminal:BOOST_MPL_ASSERT(( proto::matches< proto::terminal<std::complex<double> >::type, proto::terminal<std::complex< proto::_ > > > )); When used as a transform, proto::_ returns the current expression unchanged. For instance, in the following, proto::_ is used with the proto::fold<> transform to fold the children of a node:struct CountChildren : proto::or_< // Terminals have no children proto::when<proto::terminal<proto::_>, mpl::int_<0>()>, // Use proto::fold<> to count the children of non-terminals proto::otherwise< proto::fold< proto::_, // <-- fold the current expression mpl::int_<0>(), mpl::plus<proto::_state, mpl::int_<1> >() > > > {}; proto::transform_impl<Expr, State, Data> Expr Expr typename impl::expr_param An expression typename impl::state_param typename impl::data_param expr _ proto::transform<not_<Grammar> > Inverts the set of expressions matched by a grammar. When used as a transform, proto::not_<> returns the current expression unchanged. If an expression type E does not match a grammar G, then E does match proto::not_<G>. For example, proto::not_<proto::terminal<proto::_> > will match any non-terminal. proto::transform_impl<Expr, State, Data> Expr Expr typename impl::expr_param An expression typename impl::state_param typename impl::data_param proto::matches<Expr, proto::not_>::value is true. expr not_ proto::transform<if_<If, Then, Else> > Used to select one grammar or another based on the result of a compile-time Boolean. When used as a transform, proto::if_<> selects between two transforms based on a compile-time Boolean. When proto::if_<If, Then, Else> is used as a grammar, If must be a Proto transform and Then and Else must be grammars. An expression type E matches proto::if_<If, Then, Else> if boost::result_of<proto::when<proto::_, If>(E)>::type::value is true and E matches Then; or, if boost::result_of<proto::when<proto::_, If>(E)>::type::value is false and E matches Else. The template parameter Then defaults to proto::_ and Else defaults to proto::not_<proto::_>, so an expression type E will match proto::if_<If> if and only if boost::result_of<proto::when<proto::_, If>(E)>::type::value is true. // A grammar that only matches integral terminals, // using is_integral<> from Boost.Type_traits. struct IsIntegral : proto::and_< proto::terminal<proto::_>, proto::if_< boost::is_integral<proto::_value>()> > {}; When proto::if_<If, Then, Else> is used as a transform, If, Then and Else must be Proto transforms. When applying the transform to an expression E, state S and data V, if boost::result_of<proto::when<proto::_, If>(E,S,V)>::type::value is true then the Then transform is applied; otherwise the Else transform is applied. // Match a terminal. If the terminal is integral, return // mpl::true_; otherwise, return mpl::false_. struct IsIntegral2 : proto::when< proto::terminal<_>, proto::if_< boost::is_integral<proto::_value>(), mpl::true_(), mpl::false_() > > {}; proto::transform_impl< Expr, State, Data > typename mpl::if_< typename boost::result_of<proto::when<proto::_, If>(Expr, State, Data)>::type, typename boost::result_of<proto::when<proto::_, Then>(Expr, State, Data)>::type, typename boost::result_of<proto::when<proto::_, Else>(Expr, State, Data)>::type >::type result_type typename impl::expr_param An expression typename impl::state_param The current state typename impl::data_param A data of arbitrary type proto::when<proto::_, Then-or-Else>()(expr, state, data) if_ proto::transform<or_<G...> > For matching one of a set of alternate grammars. Alternates are tried in order to avoid ambiguity. When used as a transform, proto::or_<> applies the transform associated with the first grammar that matches the expression. An expression type E matches proto::or_<G0,G1,...Gn> if E matches any Gx for x in [0,n]. When applying proto::or_<G0,G1,...Gn> as a transform with an expression e of type E, state s and data d, it is equivalent to Gx()(e, s, d), where x is the lowest number such that proto::matches<E, Gx>::value is true. The maximun number of template arguments proto::or_<> accepts is controlled by the BOOST_PROTO_MAX_LOGICAL_ARITY macro. proto::transform_impl< Expr, State, Data > unspecified result_type typename impl::expr_param An expression typename impl::state_param The current state typename impl::data_param A data of arbitrary type Gx()(expr, state, data) , where x is the lowest number such that proto::matches<Expr, Gx>::value is true. or_ proto::transform<and_<G...> > For matching all of a set of grammars. When used as a transform, proto::and_<> applies the transform associated with each grammar in the set and returns the result of the last. An expression type E matches proto::and_<G0,G1,...Gn> if E matches all Gx for x in [0,n]. When applying proto::and_<G0,G1,...Gn> as a transform with an expression e, state s and data d, it is equivalent to (G0()(e, s, d),G1()(e, s, d),...Gn()(e, s, d)). The maximun number of template arguments proto::and_<> accepts is controlled by the BOOST_PROTO_MAX_LOGICAL_ARITY macro. proto::transform_impl< Expr, State, Data > typename boost::result_of<Gn(Expr, State, Data)>::type result_type typename impl::expr_param An expression typename impl::state_param The current state typename impl::data_param A data of arbitrary type (G0()(expr, state, data),G1()(expr, state, data),...Gn()(expr, state, data)) and_ proto::transform<switch_<Cases, Transform> > For matching one of a set of alternate grammars, which are looked up based on the result type of the transform passed in second template parameter. If no transform is passed, the default one is proto::tag_of<proto::_>() so the default matching is based on the expression's tag type. When used as a transform, proto::switch_<> applies the transform associated with the sub-grammar that matches the expression. An expression type E matches proto::switch_<C,T> if E matches C::case_<boost::result_of<proto::when<proto::_,T>(E)>::type>. When applying proto::switch_<C,T> as a transform with an expression e of type E, state s of type S and data d of type D, it is equivalent to C::case_<boost::result_of<proto::when<proto::_,T>(E,S,D)>::type>()(e, s, d). Cases::template case_< typename when<_, Transform>::template impl<Expr, State, Data>::result_type >::template impl<Expr, State, Data> switch_ For forcing exact matches of terminal types. By default, matching terminals ignores references and cv-qualifiers. For instance, a terminal expression of type proto::terminal<int const &>::type will match the grammar proto::terminal<int>. If that is not desired, you can force an exact match with proto::terminal<proto::exact<int> >. This will only match integer terminals where the terminal is held by value. For matching terminals that are convertible to a type. Use proto::convertible_to<> to match a terminal that is convertible to some type. For example, the grammar proto::terminal<proto::convertible_to<int> > will match any terminal whose argument is convertible to an integer. For matching a Grammar to a variable number of sub-expressions. An expression type proto::basic_expr<AT, proto::listN<A0,...An,U0,...Um> > matches a grammar proto::basic_expr<BT, proto::listM<B0,...Bn,proto::vararg<V> > > if BT is proto::_ or AT, and if Ax matches Bx for each x in [0,n] and if Ux matches V for each x in [0,m]. For example: // Match any function call expression, regardless // of the number of function arguments: struct Function : proto::function< proto::vararg<proto::_> > {}; When used as a transform, proto::vararg<G> applies G's transform. A Boolean metafunction that evaluates whether a given expression type matches a grammar. proto::matches<Expr, Grammar> inherits from mpl::true_ if Expr::proto_grammar matches Grammar::proto_grammar, and from mpl::false_ otherwise. Non-terminal expressions are matched against a grammar according to the following rules: The wildcard pattern, proto::_ , matches any expression. An expression proto::basic_expr<AT, proto::listN <A0,...An> > matches a grammar proto::basic_expr<BT, proto::listN <B0,...Bn> > if BT is proto::_ or AT, and if Ax matches Bx for each x in [0,n]. An expression proto::basic_expr<AT, proto::listN <A0,...An,U0,...Um> > matches a grammar proto::basic_expr<BT, proto::listM <B0,...Bn,proto::vararg<V> > > if BT is proto::_ or AT, and if Ax matches Bx for each x in [0,n] and if Ux matches V for each x in [0,m]. An expression E matches proto::or_<B0,...Bn> if E matches some Bx for x in [0,n]. An expression E matches proto::and_<B0,...Bn> if E matches all Bx for x in [0,n]. An expression E matches proto::if_<T,U,V> if: boost::result_of<proto::when<proto::_,T>(E)>::type::value is true and E matches U, or boost::result_of<proto::when<proto::_,T>(E)>::type::value is false and E matches V. Note: U defaults to proto::_ and V defaults to proto::not_<proto::_> . An expression E matches proto::not_<T> if E does not match T. An expression E matches proto::switch_<C, T> if E matches C::case_<boost::result_of<proto::when<proto::_,T>(E)>::type>. Note: T defaults to proto::tag_of<proto::_>() A terminal expression can trivially match the grammar proto::_. In addition, a terminal expression proto::basic_expr<AT, proto::term<A> > matches a grammar proto::basic_expr<BT, proto::term<B> > if BT is proto::_ or AT and one of the following is true: B is the wildcard pattern, proto::_ A is B A is B & A is B const & B is proto::exact<A> B is proto::convertible_to<X> and boost::is_convertible<A,X>::value is true. A is X[M] or X(&)[M] and B is X[proto::N] . A is X(&)[M] and B is X(&)[proto::N] . A is X[M] or X(&)[M] and B is X*. B lambda-matches A (see below). A type B lambda-matches A if one of the following is true: B is A B is the wildcard pattern, proto::_ B is T<B0,...Bn> and A is T<A0,...An> and for each x in [0,n], Ax and Bx are types such that Ax lambda-matches Bx mpl::bool_<true-or-false>