c++ - 提振 spirit 如何从父节点访问子节点(叶子)

Question

我想评估 bool 表达式，例如 a=b & s<9 或仅使用比较运算符(没有逻辑运算符，例如 |、& 和 !)的 a=b。我们可以有以下 AST:

            =
           / \
          /   \
          a    b 

或

               &
              / \  
             /   \
            =     <
           / \    /\
          /   \  /  \
          a    b s   9   

叶子节点是值。离开节点的父节点总是比较运算符，例如=、!=、<、>、>=、<=。比较节点的父节点是逻辑运算符 |、& 和 !。我想从它们的父节点访问值节点(叶子)，然后将这些值传递给另一个函数(稍后将实现)。解析步骤没问题。

如何从其父节点访问值节点(叶)。 我在以下位置使用示例: How to calculate boolean expression in Spirit

和 Boolean expression (grammar) parser in c++ 这是从这些链接中获取的评估代码:

    struct eval : boost::static_visitor<bool>
{
    eval() {}

    //
    bool operator()(const var& v) const
    {
        std::cout<<"feuille:\n"<<v<<std::endl;
        return true;
    }

    bool operator()(const binop<op_and>& b) const
    {
        recurse(b.oper1) && recurse(b.oper2);
    }
    bool operator()(const binop<op_or>& b) const
    {
        recurse(b.oper1) || recurse(b.oper2);
    }
    bool operator()(const unop<op_not>& u) const
    {
        return !recurse(u.oper1);
    }

    //------------adding others operators----------------------------
    bool operator()(const binop<op_equal>& u) const
    {
        // will be implemented later
        return true;
    }

    bool operator()(const binop<op_not_equal>& u) const
    {
       // will be implemented later
        return true;
    }

    bool operator()(const binop<op_less>& u) const
    {
        // will be implemented later
        return true;
    }

    bool operator()(const binop<op_less_equal>& u) const
    {
        // will be implemented later
        return true;
    }

    bool operator()(const binop<op_greater>& u) const
    {
        // will be implemented later
        return true;
    }
    bool operator()(const binop<op_greater_equal>& u) const
    {
        // will be implemented later
        return true;
    }

谢谢。欢迎提出任何建议。

Answer 1

您是否看过现有运算符的其他评估重载？您是否注意到它们如何获得其操作数的值(实际上可能是子表达式)？

我以二进制或为例:

bool operator()(const binop<op_or>& b) const
{
    return recurse(b.oper1) || recurse(b.oper2);
}

如您所见，它只适用于 ||到两个操作数的值。在 AST^[1] 中找不到该值。因此，我们将每个操作数视为一个表达式，并调用 eval方法，递归地。

因为表达式类型是变体，调用eval实际上是将访问者应用于变体，而我 had already written the helpful wrapper that does this so it's easy to recurse :

private:
template<typename T>
    bool recurse(T const& v) const 
    { return boost::apply_visitor(*this, v); }

所以，不知道你的语法的其余部分，但假设你按照与现有语法相同的方式扩展它:

bool operator()(const binop<op_equal>& u) const {
    return recurse(b.oper1) == recurse(b.oper2);
}

应该是对的。请注意，使用巧妙的宏，您可以非常快速地完成:

struct eval : boost::static_visitor<value> {

    // terminal
    value operator()(const var& v) const {
        std::cout<<"feuille:\n"<<v<<std::endl;
        return true; // TODO get value from var
    }

    // unary operator
    value operator()(const unop<op_not>& u) const { return !recurse(u.oper1); }

    /*
     * binary operators
     */
#define EXPR_DEF_BINOP(tag, op) \
    value operator()(const binop<tag>& u) const { \
        return recurse(b.oper1) op recurse(b.oper2); \
    }

    EXPR_DEF_BINOP(op_and,           &&)
    EXPR_DEF_BINOP(op_equal,         ==)
    EXPR_DEF_BINOP(op_greater,       >)
    EXPR_DEF_BINOP(op_greater_equal, >=)
    EXPR_DEF_BINOP(op_less,          <)
    EXPR_DEF_BINOP(op_less_equal,    <=)
    EXPR_DEF_BINOP(op_not_equal,     !=)
    EXPR_DEF_BINOP(op_or,            ||)

#undef EXPR_DEF_BINOP

  private:
    template<typename T>
        value recurse(T const& v) const 
        { return boost::apply_visitor(*this, v); }
};

一些注意事项:

• 我在叶节点评估函数中添加了一个 TODO

• 我将类型更改为 value (来自 bool)。这是因为你的语法支持非 bool 表达式，否则运算符 <=和 >=没有意义。^[2]，因此您将拥有不同类型的值(也):

  using value = variant<bool, int32_t>;
  

  剩下的交给你

---

^[1] 请记住 AST = 抽象语法树:它是源的 1:1 表示。 (“半异常”将是字面量，尽管您仍然需要告诉计算器如何使用字面量的值。)

^[2] 可以说是

• a<b可能暗示 !a && b
• a>b可能暗示 !b && a
• a!=b可能暗示 a XOR b
• a==b可能暗示 !(a XOR b)