I have my eUML grammar, defing, for example a transition as:
SourceState+ Event [some_guard] == TargetState
I want to write for some_guard an expression of a phoenix grammar. The
relevant part of the expression is:
Where the corresponding part of my grammar is:
BuildGuards is, at the moment, a proto::switch_ grammar, which I want
to replace with something matching a phoenix grammar and returning me
a phoenix::actor<Expr>, which I will then save into TempRow.
I suppose I could typeof/decltype the phoenix expression but it
doesn't seem like the best solution, I'd prefer to delay this.
Is there something like a phoenix grammar which I can call to check if
the expression is valid, and if yes, which will return me the correct
Second question. Now it's becoming more "interesting". And not easy to
For eUML, a guard can be defined as "g1 && g2", where g1 and g2 are
functors, taking 4 arguments. For example (to make short):
template <class FSM,class EVT,class SourceState,class TargetState>
void operator()(EVT const& ,FSM&,SourceState& ,TargetState& )
The fact that there are 4 arguments is the condition to make this work
I 'm pretty sure that, while this clearly should be a function for
phoenix, I would not like the syntax:
g1(arg1,arg2,arg3,arg4) && g2(arg1,arg2,arg3,arg4).
Is it possible to define g1 and g2 as custom terminals, but still get
them treated like functions?
(To solve the problem, my current implementation generates me a
functor of type And_<g1,g2> which has an operator () with 4
proto mailing list