1

我想评估布尔表达式，例如 a=b & s<9 或仅使用比较运算符（没有逻辑运算符，例如 |、& 和！）的 a=b。我们可以有以下 AST：

            =
           / \
          /   \
          a    b

或者

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

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

如何从其父节点访问值节点（叶子）。我正在使用示例： 如何在 Spirit 中计算布尔表达式

和 c++ 中的布尔表达式（语法）解析器 这是取自以下链接的评估代码：

    结构 eval : boost::static_visitor<bool>
{
    评估（）{}

    //
    bool operator()(const var& v) const
    {
        std::cout<<"feuille:\n"<<v<<std::endl;
        返回真；
    }

    bool operator()(const binop<op_and>& b) const
    {
        递归(b.oper1) && 递归(b.oper2);
    }
    bool operator()(const binop<op_or>& b) const
    {
        递归（b.oper1）|| 递归（b.oper2）；
    }
    bool operator()(const unop<op_not>& u) const
    {
        返回 !recurse(u.oper1);
    }

    //------------添加其他操作符----------------------------
    bool operator()(const binop<op_equal>& u) const
    {
        // 稍后实现
        返回真；
    }

    bool operator()(const binop<op_not_equal>& u) const
    {
       // 稍后实现
        返回真；
    }

    bool operator()(const binop<op_less>& u) const
    {
        // 稍后实现
        返回真；
    }

    bool operator()(const binop<op_less_equal>& u) const
    {
        // 稍后实现
        返回真；
    }

    bool operator()(const binop<op_greater>& u) const
    {
        // 稍后实现
        返回真；
    }
    bool operator()(const binop<op_greater_equal>& u) const
    {
        // 稍后实现
        返回真；
    }

谢谢你。欢迎任何建议。

4

1 回答 1

1

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

让我以二进制或为例：

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

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

因为表达式类型是变体，调用eval实际上是将访问者应用到变体，我已经编写了有用的包装器来执行此操作，因此很容易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）。这是因为您的语法支持非布尔表达式，否则运算符<=并没>=有意义。[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)
于 2013-10-18T12:32:01.813 回答