c++ - AST and operator precedence in rule definition

Question

Hello ^[1]

I have a simple parser (see below).

It intends to parse conditional expressions (relational arithmetic operations and logic combinations thereof).

In the example given there, it parses successfully A>5 but then stops and ignores the rest of the input, and this is consistent with my impl.

How do I change the expr_ rule to make it parse the entire input?

#include <cstdint>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/variant/recursive_wrapper.hpp>

namespace qi    = boost::spirit::qi;
namespace phx   = boost::phoenix;

/// Terminals
enum metric_t : std::uint8_t { A=0u, B };
const std::string metric_names[] = { "A", "B" };
struct metrics_parser : boost::spirit::qi::symbols<char, metric_t>
{
metrics_parser()
{
    this->add
    ( metric_names[A], A )
    ( metric_names[B], B )
    ;
}
};


/// Operators
struct op_or  {};
struct op_and {};
struct op_xor {};
struct op_not {};

struct op_eq {};
struct op_lt {};
struct op_let {};
struct op_gt {};
struct op_get {};

template <typename tag> struct unop;
template <typename tag> struct binop;

/// Expression
typedef boost::variant<
int,
double,
metric_t,
boost::recursive_wrapper< unop<op_not> >,
boost::recursive_wrapper< binop<op_and> >,
boost::recursive_wrapper< binop<op_or> >,
boost::recursive_wrapper< binop<op_xor> >,
boost::recursive_wrapper< binop<op_eq> >,
boost::recursive_wrapper< binop<op_lt> >,
boost::recursive_wrapper< binop<op_gt> >
> expr;

template <typename tag>
struct binop 
{ 
    explicit binop(const expr& l, const expr& r) : oper1(l), oper2(r) { }
    expr oper1, oper2; 
};

template <typename tag>
struct unop  
{ 
    explicit unop(const expr& o) : oper1(o) { }
    expr oper1; 
};

struct printer : boost::static_visitor<void>
{
    printer(std::ostream& os) : _os(os) {}
    std::ostream& _os;

    void operator()(const binop<op_and>& b) const { print(" and ", b.oper1, b.oper2); }
    void operator()(const binop<op_or >& b) const { print(" or ",  b.oper1, b.oper2);  }
    void operator()(const binop<op_xor>& b) const { print(" xor ", b.oper1, b.oper2); }
    void operator()(const binop<op_eq>& b) const  { print(" = ",   b.oper1, b.oper2);   }
    void operator()(const binop<op_lt>& b) const  { print(" < ",   b.oper1, b.oper2);   }
    void operator()(const binop<op_gt>& b) const  { print(" > ",   b.oper1, b.oper2);   }

    void print(const std::string& op, const expr& l, const expr& r) const
    {
        _os << "(";
            boost::apply_visitor(*this, l);
            _os << op;
            boost::apply_visitor(*this, r);
        _os << ")";
    }

    void operator()(const unop<op_not>& u) const
    {
        _os << "(";
            _os << "!";
            boost::apply_visitor(*this, u.oper1);
        _os << ")";
    }
    void operator()(metric_t m) const
    {
    _os << metric_names[m];
    }

    template <typename other_t>
    void operator()(other_t i) const
    {
    _os << i;
    }
};

std::ostream& operator<<(std::ostream& os, const expr& e)
{ boost::apply_visitor(printer(os), e); return os; }

std::ostream& operator<<(std::ostream& os, metric_t m)
{ os<< metric_names[m]; return os; }

template <typename It, typename Skipper = qi::space_type>
struct parser : qi::grammar<It, expr(), Skipper>
{
    parser() : parser::base_type(expr_)
    {
        using namespace qi;
        using namespace phx;
        using local_names::_a;

        number_r_ %= int_ | double_;

        metric_r_ %= metric_p_;

        eq_r_ =
        (metric_r_ >> "=" >> number_r_)  
            [ _val = phx::construct< binop<op_eq> >(_1,_2) ] |
        (metric_r_ >> "!=" >> number_r_) 
            [ _val = phx::construct< unop<op_not> >( phx::construct< binop<op_eq> >(_1,_2) ) ]
        ;

        ineq_r_ =
        (metric_r_ >> ">" >> number_r_)  
            [ _val = phx::construct< binop<op_gt> >(_1,_2) ] |
        (metric_r_ >> "<" >> number_r_)  
            [ _val = phx::construct< binop<op_lt> >(_1,_2) ] |
        (metric_r_ >> ">=" >> number_r_) 
            [ _val = phx::construct< binop<op_or> >( 
            phx::construct< binop<op_gt> >(_1,_2),
            phx::construct< binop<op_eq> >(_1,_2) ) 
            ] |
        (metric_r_ >> "<=" >> number_r_) 
            [ _val = phx::construct< binop<op_or> >( 
            phx::construct< binop<op_lt> >(_1,_2), 
            phx::construct< binop<op_eq> >(_1,_2) )
            ]
        ;

        ineq_2_r_ = 
        (number_r_ >> "<" >> metric_r_ >> "<" >> number_r_)
            [ _val = phx::construct< binop<op_and> >(
            phx::construct< binop<op_gt> >(_2,_1), 
            phx::construct< binop<op_lt> >(_2,_3) ) 
            ] |
        (number_r_ >> "<=" >> metric_r_ >> "<" >> number_r_)
            [ _val = phx::construct< binop<op_and> >(
            phx::construct< binop<op_or> >(
                phx::construct< binop<op_gt> >(_2,_1),
                phx::construct< binop<op_eq> >(_2,_1)
            ),
            phx::construct< binop<op_lt> >(_2,_3) )
            ] |
        (number_r_ >> "<" >> metric_r_ >> "<=" >> number_r_)
            [ _val = phx::construct< binop<op_and> >(
            phx::construct< binop<op_gt> >(_2,_1),
            phx::construct< binop<op_or> >(                
                phx::construct< binop<op_eq> >(_2,_3),
                phx::construct< binop<op_lt> >(_2,_3) )
            )
            ] |
        (number_r_ >> "<=" >> metric_r_ >> "<=" >> number_r_)
            [ _val = phx::construct< binop<op_and> >(
            phx::construct< binop<op_or> >(
                phx::construct< binop<op_eq> >(_2,_1),
                phx::construct< binop<op_gt> >(_2,_1) 
            ),
            phx::construct< binop<op_or> >(                
                phx::construct< binop<op_eq> >(_2,_3),
                phx::construct< binop<op_lt> >(_2,_3)
            )
            )
            ]
        ;

        expr_  = 
        eq_r_                     [ _val = _1 ]                                     |
        ineq_r_                   [ _val = _1 ]                                     |
        ineq_2_r_                 [ _val = _1 ]                                     |
        ("not" >> expr_)          [ _val = phx::construct< unop<op_not> >(_1) ]     |
        (expr_ >> "and" >> expr_) [ _val = phx::construct< binop<op_and> >(_1,_2) ] |
        (expr_ >> "or" >> expr_)  [ _val = phx::construct< binop<op_or>  >(_1,_2) ] |
        (expr_ >> "xor" >> expr_) [ _val = phx::construct< binop<op_xor> >(_1,_2) ];

        metric_r_.name("metric r");
        eq_r_.name("eq_r_");
        ineq_r_.name("ineq_r_");
        ineq_2_r_.name("ineq_2_r_");
        expr_.name("expr_");
        debug(metric_r_);
        debug(eq_r_);
        debug(ineq_r_);
        debug(ineq_2_r_);
        debug(expr_);
    }

private:
    metrics_parser                metric_p_;
    qi::rule<It, expr(), Skipper> number_r_;
    qi::rule<It, expr(), Skipper> metric_r_;
    qi::rule<It, expr(), Skipper> eq_r_;
    qi::rule<It, expr(), Skipper> ineq_r_;
    qi::rule<It, expr(), Skipper> ineq_2_r_;
    qi::rule<It, expr(), Skipper> expr_;
};



int main()
{
    std::list<std::string> lstr;
    lstr.emplace_back("A>5 and B<4 xor A>3.4 or 2<A<3");

    for (auto i=std::begin(lstr); i!=std::end(lstr); ++i)
    {
        auto& input = *i;

        auto f(std::begin(input)), l(std::end(input));
        parser<decltype(f)> p;

        try
        {
            expr result;
            bool ok = qi::phrase_parse(f,l,p,qi::space,result);

            if (!ok)
                std::cerr << "invalid input
";
            else
                std::cout << "result: " << result << "
";

        } catch (const qi::expectation_failure<decltype(f)>& e)
        {
            std::cerr << "expectation_failure at '" << std::string(e.first, e.last) << "'
";
        }

        if (f!=l) std::cerr << "unparsed: '" << std::string(f,l) << "'
";
    }

    return 0;
}

---

^{Thanks, MM}

^{[1] question teleported from the [spirit-general] user list}

Answer 1

Sticking with simple:

relop_expr = eq_r_ | ineq_r_ | ineq_2_r_;

expr_  =
  ("not" >> expr_)               [ _val = phx::construct< unop<op_not> >(_1) ]     |
  (relop_expr >> "and" >> expr_) [ _val = phx::construct< binop<op_and> >(_1,_2) ] |
  (relop_expr >> "or" >> expr_)  [ _val = phx::construct< binop<op_or>  >(_1,_2) ] |
  (relop_expr >> "xor" >> expr_) [ _val = phx::construct< binop<op_xor> >(_1,_2) ] |
  (relop_expr                  ) [ _val = _1 ]
  ;

 BOOST_SPIRIT_DEBUG_NODES((metric_r_)(eq_r_)(ineq_r_)(ineq_2_r_)(relop_expr)(expr_))

Note:

• the ordering of branches
• the use of an extra "level" (relop_expr) to induce precedence

There's still work to do (3.4 did not parse yet, and neither did 2<A<3). Also, it's excruciatingly inefficient (could do with left factorization). Fixing those:

number_r_ = real_parser<double,strict_real_policies<double>>() | int_;

relop_expr = eq_r_ | ineq_2_r_ | ineq_r_;

expr_  =
  ("not" >> expr_)       [ _val = construct<unop<op_not>> (_1) ] |
  relop_expr [_a = _1] >> (
         ("and" >> expr_ [ _val = bin_<op_and>() ]) |
         ("or"  >> expr_ [ _val = bin_<op_or >() ]) |
         ("xor" >> expr_ [ _val = bin_<op_xor>() ]) |
         (eps            [ _val = _a ])
    )
  ;

As you can see, I can't really stand those complicated semantic actions. The chief reason for this is BUGS. Make the code readable, lose half the bugs. So, with just a two simple helpers we can reduce the verbosity:

template <typename Tag>             using bin_  = decltype(phx::construct<binop<Tag>>(qi::_a, qi::_1));
template <typename T1, typename T2> using tern_ = decltype(phx::construct<binop<op_and>>(phx::construct<binop<T1>>(qi::_a, qi::_1), phx::construct<binop<T2>>(qi::_1, qi::_2)));

As you can see, I don't make a great effort to write traits etc. Just a quick decltype on whatever you'd write anyways, and, bam

down from 35 crufty lines to 4 very clean lines:

ineq_2_r_ = number_r_ [ _a = _1 ] >> (
     ("<"  >> metric_r_ >> "<"  >> number_r_) [_val = tern_<op_lt , op_lt>()  ] |
     ("<"  >> metric_r_ >> "<=" >> number_r_) [_val = tern_<op_lt , op_lte>() ] |
     ("<=" >> metric_r_ >> "<"  >> number_r_) [_val = tern_<op_lte, op_lt>()  ] |
     ("<=" >> metric_r_ >> "<=" >> number_r_) [_val = tern_<op_lte, op_lte>() ] |

// see, that's so easy, we can even trow in the bonus - I bet you were just fed up with writing boiler plate :)

     (">"  >> metric_r_ >> ">"  >> number_r_) [_val = tern_<op_gt , op_gt>()  ] |
     (">"  >> metric_r_ >> ">=" >> number_r_) [_val = tern_<op_gt , op_gte>() ] |
     (">=" >> metric_r_ >> ">"  >> number_r_) [_val = tern_<op_gte, op_gt>()  ] |
     (">=" >> metric_r_ >> ">=" >> number_r_) [_val = tern_<op_gte, op_gte>() ]
 );

Oh, I just remembered: I have defined the op_gte and op_lte operators, since not having them was causing quadratic growth of your semantic actions. My fast rule of thumb is:

• Rule #1: keep rules simple, avoid semantic actions
• Corollary #1: make your AST directly reflect the grammar.

In this case, you were conflating AST transformation with parsing. If you want to transform the AST to 'expand' lte (a,b) <- (lt(a,b) || eq(a,b)), you can trivially do that after parsing. Update see the other answer for a demo

All in all, I have attached the suggestions in a working program. It implements many more features, and comes in 73 lines shorter (28%). That's even with more test cases:

'A  >  5':    result: (A > 5)
'A  <  5':    result: (A < 5)
'A  >= 5':    result: (A >= 5)
'A  <= 5':    result: (A <= 5)
'A   = 5':    result: (A = 5)
'A  != 5':    result: !(A = 5)
'A>5 and B<4 xor A>3.4 or 2<A<3':    result: ((A > 5) and ((B < 4) xor ((A > 3.4) or ((2 < A) and (A < 3)))))
'A>5 and B<4 xor A!=3.4 or 7.9e10 >= B >= -42':    result: ((A > 5) and ((B < 4) xor (!(A = 3.4) or ((7.9e+10 >= B) and (B >= -42)))))

Well, I'd have shown it live on Coliru, but it seems down at the moment. Hope you like this.

Full sample

//#define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/variant/recursive_wrapper.hpp>
#include <cstdint>

namespace qi    = boost::spirit::qi;
namespace phx   = boost::phoenix;

/// Terminals
enum metric_t : std::uint8_t { A=0u, B };
const std::string metric_names[] = { "A", "B" };

struct metrics_parser : boost::spirit::qi::symbols<char, metric_t> {
    metrics_parser() {
        this->add(metric_names[A], A)
                 (metric_names[B], B);
    }
};

/// Operators
template <typename tag> struct unop;
template <typename tag> struct binop;

/// Expression
typedef boost::variant<
  int,
  double,
  metric_t,
  boost::recursive_wrapper< unop< struct op_not> >,
  boost::recursive_wrapper< binop<struct op_and> >,
  boost::recursive_wrapper< binop<struct op_or> >,
  boost::recursive_wrapper< binop<struct op_xor> >,
  boost::recursive_wrapper< binop<struct op_eq> >,
  boost::recursive_wrapper< binop<struct op_lt> >,
  boost::recursive_wrapper< binop<struct op_gt> >,
  boost::recursive_wrapper< binop<struct op_lte> >,
  boost::recursive_wrapper< binop<struct op_gte> >
> expr;

template <typename tag>
struct binop { 
    explicit binop(const expr& l, const expr& r) : oper1(l), oper2(r) { }
    expr oper1, oper2; 
};

template <typename tag>
struct unop  { 
    explicit unop(const expr& o) : oper1(o) { }
    expr oper1; 
};

std::ostream& operator<<(std::ostream& os, metric_t m)
{ return os << metric_names[m]; }

struct printer : boost::static_visitor<void>
{
    printer(std::ostream& os) : _os(os) {}
    std::ostream& _os;

    void operator()(const binop<op_and>& b) const { print(" and ", b.oper1, b.oper2); }
    void operator()(const binop<op_or >& b) const { print(" or ",  b.oper1, b.oper2); }
    void operator()(const binop<op_xor>& b) const { print(" xor ", b.oper1, b.oper2); }
    void operator()(const binop<op_eq >& b) const { print(" = ",   b.oper1, b.oper2); }
    void operator()(const binop<op_lt >& b) const { print(" < ",   b.oper1, b.oper2); }
    void operator()(const binop<op_gt >& b) const { print(" > ",   b.oper1, b.oper2); }
    void operator()(const binop<op_lte>& b) const { print(" <= ",  b.oper1, b.oper2); }
    void operator()(const binop<op_gte>& b) const { print(" >= ",  b.oper1, b.oper2); }

    void print(const std::string& op, const expr& l, const expr& r) const {
        _os << "(";
        boost::apply_visitor(*this, l); _os << op; boost::apply_visitor(*this, r);
        _os << ")";
    }

    void operator()(const unop<op_not>& u) const {
        _os << "!"; boost::apply_visitor(*this, u.oper1);
    }

    template <typename other_t> void operator()(other_t i) const { 
        _os << i; 
    }
};

std::ostream& operator<<(std::ostream& os, const expr& e)
{ boost::apply_visitor(printer(os), e); return os; }

template <typename It, typename Skipper = qi::space_type >
struct parser : qi::grammar<It, expr(), Skipper, qi::locals<expr> >
{
    template <typename Tag>             using bin_  = decltype(phx::construct<binop<Tag>>(qi::_a, qi::_1));
    template <typename T1, typename T2> using tern_ = decltype(phx::construct<binop<op_and>>(phx::construct<binop<T1>>(qi::_a, qi::_1), phx::construct<binop<T2>>(qi::_1, qi::_2)));

    parser() : parser::base_type(expr_)
    {
        using namespace qi;
        using namespace phx;

        number_r_ = real_parser<double,strict_real_policies<double>>() | int_;

        metric_r_ = metric_p_;

        eq_r_ = metric_r_ [ _a = _1 ] >> (
                ("="  >> number_r_) [ _val = bin_<op_eq>() ] |
                ("!=" >> number_r_) [ _val = construct<unop<op_not>>(bin_<op_eq>()) ]
            );
        ineq_2_r_ = number_r_ [ _a = _1 ] >> (
                ("<"  >> metric_r_ >> "<"  >> number_r_) [_val = tern_<op_lt , op_lt>()  ] |
                ("<"  >> metric_r_ >> "<=" >> number_r_) [_val = tern_<op_lt , op_lte>() ] |
                ("<=" >> metric_r_ >> "<"  >> number_r_) [_val = tern_<op_lte, op_lt>()  ] |
                ("<=" >> metric_r_ >> "<=" >> number_r_) [_val = tern_<op_lte, op_lte>() ] |
                (">"  >> metric_r_ >> ">"  >> number_r_) [_val = tern_<op_gt , op_gt>()  ] |
                (">"  >> metric_r_ >> ">=" >> number_r_) [_val = tern_<op_gt , op_gte>() ] |
                (">=" >> metric_r_ >> ">"  >> number_r_) [_val = tern_<op_gte, op_gt>()  ] |
                (">=" >> metric_r_ >> ">=" >> number_r_) [_val = tern_<op_gte, op_gte>() ]
            );
        ineq_r_ = metric_r_ [ _a = _1 ] >> (
                (">" >> number_r_)  [ _val = bin_<op_gt >() ] |
                ("<" >> number_r_)  [ _val = bin_<op_lt >() ] |
                (">=" >> number_r_) [ _val = bin_<op_gte>() ] |
                ("<=" >> number_r_) [ _val = bin_<op_lte>() ]
            );

        relop_expr = eq_r_ | ineq_2_r_ | ineq_r_;

        expr_  = 
            ("not" >> expr_)       [ _val = construct<unop<op_not>> (_1) ] |
            relop_expr [_a = _1] >> (
                 ("and" >> expr_ [ _val = bin_<op_and>() ]) |
                 ("or"  >> expr_ [ _val = bin_<op_or >() ]) |
                 ("xor" >> expr_ [ _val = bin_<op_xor>() ]) |
                 (eps            [ _val = _a ])
            );

        BOOST_SPIRIT_DEBUG_NODES((metric_r_)(eq_r_)(ineq_r_)(ineq_2_r_)(relop_expr)(expr_))
    }
  private:
    qi::rule<It, expr(), Skipper, qi::locals<expr> > eq_r_, ineq_r_, ineq_2_r_, relop_expr, expr_;
    qi::rule<It, expr(), Skipper>                    number_r_, metric_r_;
    metrics_parser                                   metric_p_;
};

int main()
{
    for (std::string const& input : { 
        "A  >  5",
        "A  <  5",
        "A  >= 5",
        "A  &l