C++ Boost spirit ，对同一个_val 进行多次评估？

Question

我试图从这里修改一个 bool 表达式解析器:Boolean expression (grammar) parser in c++

在创建变量的过程中，我尝试调用一个新函数“processval”。它只是带有一些输出的身份函数，以查看何时调用此函数。但问题是，当我只有 2 个变量时，这个函数被调用了 10 多次。有人知道为什么吗？

密码是here

#define BOOST_SPIRIT_USE_PHOENIX_V3
#include <iostream>
#include <string>
#include <boost/phoenix/function/adapt_function.hpp>
#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;

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

typedef int var;
template <typename tag> struct binop;
template <typename tag> struct unop;

typedef boost::variant<var, 
        boost::recursive_wrapper<unop <op_not> >, 
        boost::recursive_wrapper<binop<op_and> >,
        boost::recursive_wrapper<binop<op_xor> >,
        boost::recursive_wrapper<binop<op_or> >
        > 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 var& v) const { _os << v; }

    void operator()(const binop<op_and>& b) const { print(" & ", b.oper1, b.oper2); }
    void operator()(const binop<op_or >& b) const { print(" | ", b.oper1, b.oper2); }
    void operator()(const binop<op_xor>& 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 << ")";
    }
};

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

int processval(int s)
{
    std::cout << "processing val : " << s << std::endl;
    return s;
}

BOOST_PHOENIX_ADAPT_FUNCTION(int, process_, processval, 1)

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

        expr_  = or_.alias();

        or_  = (xor_ >> "or"  >> or_ ) [ _val = phx::construct<binop<op_or >>(_1, _2) ] | xor_   [ _val = _1 ];
        xor_ = (and_ >> "xor" >> xor_) [ _val = phx::construct<binop<op_xor>>(_1, _2) ] | and_   [ _val = _1 ];
        and_ = (not_ >> "and" >> and_) [ _val = phx::construct<binop<op_and>>(_1, _2) ] | not_   [ _val = _1 ];
        not_ = ("not" > simple       ) [ _val = phx::construct<unop <op_not>>(_1)     ] | simple [ _val = _1 ];

        simple = (('(' > expr_ > ')') | var_);
        var_ = int_ [ _val = process_(_1) ];

    }

  private:
    qi::rule<It, var() , Skipper> var_;
    qi::rule<It, expr(), Skipper> not_, and_, xor_, or_, simple, expr_;
};

int main()
{
    for (auto& input : std::list<std::string> {
        "1 and 2"
            })
    {
        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\n";
            else
                std::cout << "result: " << result << "\n";

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

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

    return 0;
}

编辑:

最好的解决办法是改变语法。参见 Bill's comment

Answer 1

这与像 spirit 这样的解析器如何工作有关。让我们看看这些对 processval() 的调用发生在哪里:

让我们用一个更简单的语法来谈谈会发生什么:

A = (B >> C) | (B >> B >> C)
B = "B" [ process_(_1) ]
C = "C"

给定输入 "BBC"，我们实际上将解析 B 三次!这意味着我们附加的任何语义操作(如 _process)也将执行 3 次。

让我们通过解析来说明为什么会发生这种情况:

1. 我们从 A 开始。
2. 我们应该尝试的 A 中的第一个表达式是 B >> C。
3. 该表达式中的第一个 B 成功解析。所以我们执行语义 Action 。
4. 然后我们应该在 B 之后加上 C。此解析失败，因为我们字符串中的下一个元素是 B。
5. 然后我们沿着解析树向上走，直到我们在 A 规则中找到替代方案。
6. 现在，我们可以选择 A = B >> B >> C。让我们试试这个。
7. 第一个B 解析成功。所以我们第二次调用我们的语义 Action 。
8. 第二个B 解析成功。所以我们第三次调用我们的语义 Action 。
9. C 解析成功。
10. 这意味着A已经解析成功。