On 06/01/2007 09:36 AM, Eric Niebler wrote:

Larry Evans wrote: [snip]

...

where the expression tree node argument remains "packaged":

(expr<Tag, Left, Right> const &expr)

[snip] different, though. You'll need something like:

struct my_context { template<typename Expr> struct eval { typedef ... result_type; result_type operator()(Expr &expr, my_context &ctx) const { return ...; } }; };

[snip] Great! I started coding and then thought about creating a "catchall" method to handle any node. I got to here: struct xmpl_context { explicit xmpl_context(unsigned& a_indent) : indent(a_indent) { } template<typename Expr, long Arity = Expr::arity::value> struct eval { typedef void result_type; result_type operator()(Expr &expr, xmpl_context &ctx) const { typedef proto::tagof<Expr>::type tag_type; const char*tag_name=std::typeid(tag_type).name() std::cout<<std::setw(indent) <<""<<tag_name<<".get_instance=" <<expr.get_instance()<<"\n"; indent+=2; for(long ichild=0; ichild<Arity; ++ichild) { proto::eval(proto::arg_c<Expr,ichild>(expr), *this); } indent-=2; } }; private: unsigned& indent; }; ...then realized I needed something like mpl's for_each. I noticed in boost/xpressive/proto/fusion.hpp there's children templates, but they don't look like they'd help. How do I do what's implied by the above for loop? Thanks again. -regards, Larry

On 06/01/2007 03:34 PM, Maurizio Vitale wrote:

Larry Evans <cppljevans@cox-internet.com> writes: [snip]

...

struct xmpl_context { explicit xmpl_context(unsigned& a_indent) : indent(a_indent) { }

template<typename Expr, long Arity = Expr::arity::value> struct eval {

typedef void result_type; result_type operator()(Expr &expr, xmpl_context &ctx) const { typedef proto::tagof<Expr>::type tag_type; const char*tag_name=std::typeid(tag_type).name() std::cout<<std::setw(indent) <<""<<tag_name<<".get_instance=" <<expr.get_instance()<<"\n"; indent+=2; for(long ichild=0; ichild<Arity; ++ichild) { proto::eval(proto::arg_c<Expr,ichild>(expr), *this); } indent-=2; } };

private: unsigned& indent;

};

I noticed in boost/xpressive/proto/fusion.hpp there's children templates, but they don't look like they'd help. How do I do what's implied by the above for loop?

It seems to me you're duplicating what display_expr does (in debug.hpp), but if the question is more general and you need to do something else you can look at proto::transform::fold (or fold_to_list if you need more persistence).

You're almost right about duplicating display_expr; however, my purpose was to see if I could access and printout the extension, xmpl_delta that was shown in my earlier post. Of course this xmpl_delta is not my ultimate goal, but, hopefully, it will show me, at least partly, how to achieve that ultimate goal. (BTW, that goal is the calculation of first and follow attributes of the grammar subexpressions as done here: http://svn.boost.org/trac/boost/browser/sandbox/boost/grammar_pipeline/eff/p... IOW, xmpl_delta would be replaced by the lookahead_attributes found on line 89 of productions.hpp. ). BTW, I have made some progress in solving the problem. It looks like: struct xmpl_context { explicit xmpl_context(unsigned& a_indent) : indent(a_indent) { } template<typename Expr, long Arity = Expr::arity::value> struct eval { struct eval_child_i { Expr const& my_parent; xmpl_context& my_context; eval_child_i ( Expr const& a_parent , xmpl_context& a_context ) : my_parent(a_parent) , my_context(a_context) {} template<long Index> void operator()(mpl::integral_c<long,Index>&) { proto::eval(proto::arg_c<Expr,Index>(my_parent),my_context); } }; typedef unsigned result_type; result_type operator()(Expr const &expr, xmpl_context &ctx) { typedef typename proto::tag_of<Expr>::type tag_type; const char*tag_name=typeid(tag_type).name(); std::cout<<std::setw(ctx.indent)<<""<<tag_name<<".get_instance="<<expr.get_instance()<<"\n"; ctx.indent+=2; typedef typename mpl::range_c<long,0,Arity>::type indices_type; eval_child_i a_eval_child(expr,ctx); mpl::for_each<indices_type>(a_eval_child); ctx.indent-=2; return ctx.indent; } }; private: unsigned& indent; }; However, I'm still getting compile errors: extend_transform_xmpl.cpp:142: instantiated from here extend_transform_xmpl.cpp:59: error: no matching function for call to 'arg_c(const xmpl_expression<boost::proto::expr<boost::proto::tag::terminal, boost::proto::args1<arg_id<1u> >, 1l> >&)' and still investigating. Thanks for the suggestions. -regards, Larry [snip]

Larry Evans wrote:

...

...

for(long ichild=0; ichild<Arity; ++ichild) { proto::eval(proto::arg_c<Expr,ichild>(expr), *this); }

That's really not going to work. If you #include proto/fusion.hpp, you can use fusion::for_each on the children nodes as follows: fusion::for_each( proto::children_of(expr), myfunc() );

template<long Index> void operator()(mpl::integral_c<long,Index>&) {

proto::eval(proto::arg_c<Expr,Index>(my_parent),my_context);

And yours is another way to skin the cat, but this line needs to be: proto::eval(proto::arg_c<Index>(my_parent),my_context); HTH, -- Eric Niebler Boost Consulting www.boost-consulting.com

Eric, just for my understanding, your suggestion is also the only way to proceed when the result type depends on Expr, right? Thanks, Maurizio On Jun 1, 2007, at 10:36 AM, Eric Niebler wrote:

Larry Evans wrote:

...

Hi Eric,

I need a context with something like the following methods:

template< typename Tag, typename Left, typename Right > result_type operator()(expr<Tag, Left, Right> const &expr) const { std::cout<<std::setw(indent) <<""<<"binary_expr:"<<expr.get_instance()<<"\n"; indent+=2; proto::eval(left, *this); proto::eval(right, *this); indent-=2; }

where the expression tree node argument remains "packaged":

(expr<Tag, Left, Right> const &expr)

in contrast to the unpacked version:

(Tag, Left const &left, Right const &right)

Sure. Only context types derived from callable_context get unpacked nodes like that. If you don't inherit from callable_context, you'll get the whole node without any modification. The interface is a bit different, though. You'll need something like:

struct my_context { template<typename Expr> struct eval { typedef ... result_type; result_type operator()(Expr &expr, my_context &ctx) const { return ...; } }; };

If you want to handle binary nodes specially, you would define the eval member template as:

template<typename Expr, long Arity = Expr::arity::value> struct eval

and then partially specialize for binary nodes:

template<typename Expr> struct eval<Expr, 2>

HTH,

-- Eric Niebler Boost Consulting www.boost-consulting.com _______________________________________________ Unsubscribe & other changes: http://lists.boost.org/mailman/ listinfo.cgi/boost

On Aug 27, 2007, at 11:54 AM, Eric Niebler wrote:

(Sorry for the delay, I'm just back from a week-long vacation.)

Not a problem, I know all about your whereabouts from your posts. Avid reader of yours I am...

Maurizio Vitale wrote:

...

On Jun 1, 2007, at 10:36 AM, Eric Niebler wrote:

...

Only context types derived from callable_context get unpacked nodes like that. If you don't inherit from callable_context, you'll get the whole node without any modification. The interface is a bit different, though. You'll need something like:

struct my_context { template<typename Expr> struct eval { typedef ... result_type; result_type operator()(Expr &expr, my_context &ctx) const { return ...; } }; };

If you want to handle binary nodes specially, you would define the eval member template as:

template<typename Expr, long Arity = Expr::arity::value> struct eval

and then partially specialize for binary nodes:

template<typename Expr> struct eval<Expr, 2>

Eric, just for my understanding, your suggestion is also the only way to proceed when the result type depends on Expr, right?

Not so. If your context type inherits from callable_context, you can define a nested result class template for calculating the return type. In this way, the return type can be made to depend on the expression type.

but you still need to explicitly pass the expression type to the context, like this: template<typename Expr> struct my_context : callabla_context<my_context<Expr> > { typedef Functor_Of<Expr>::type result_type; .... }; or am I missing a way to get to Expr in a class inheriting from callable_context? you cannot overload operator()() or you ruin the unpackaging done by callable_context. I'm using the above in my code (even though I did forget about it when asking), so if there was a better way I'd be glad to hear. Regards, Maurizio