如何使用boost::spirit验证代数表达式？

Question

如何使用boost::spirit验证代数表达式？

c++parsingboostboost-spiritboost-spirit-qi

5

我试图扩展计算器示例，以便解析和评估代数表达式的同时，解析器将确定代数语句是否为真。我指的是像 1 + 5 * 5-10 = 19-3 （期望解析器结果为true）和 3-1 = 9 （期望解析器结果为false）这样的语句。

我必须承认，我对boost::spirit还很陌生，在此时感到有些不知所措。然而，我确实觉得我理解计算器示例足够好，至少可以有所进展。

使用提供的示例作为起点，该语法如下：

calculator() : calculator::base_type(expression)
{
    using qi::uint_;
    using qi::_val;
    using qi::_1;

    expression =
        term                    [_val = _1]
            >> *( ('+' >> term  [_val = _val + _1])
                | ('-' >> term  [_val = _val - _1])
                );

        term =
            factor                [_val = _1]
            >> *( ('*' >> factor  [_val = _val * _1])
                | ('/' >> factor  [_val = _val / _1])
                );

        factor =
            uint_                 [_val = _1]
            |   '(' >> expression [_val = _1] >> ')'
            |   ('-' >> factor    [_val = -_1])
            |   ('+' >> factor    [_val = _1]);
}

为了简洁起见，我省略了调试宏。为了限制问题的范围，我决定每个语句只允许出现一个等号。由于在括号内部出现等号是毫无意义的（至少在常规情况下），因此我决定不允许使用括号。这通过允许删除可选的'(' >> expression [_val = _1] >> ')'简化了factor-parser。

目前为止，我遇到了一些困难。首先，我需要解析器接受单个等号。其次，我需要语义操作分别评估语句的左侧(LHS)和右侧(RHS)，然后最终进行比较（或者这就是我认为需要完成的操作）。

我想知道最简单的方法是否是构建两个单独的解析器，一个用于LHS，另一个用于RHS，由匹配相等符号的第三个解析器分隔。这两个解析器LHS和RHS应该是相同的，除了语义操作外。显然，这需要将输入分成两个不同的类别，以便最终进行比较。

在尝试编写两个单独的解析器LHS和RHS之前，我想学习如何修改原始解析器，以便将评估的表达式存储在本地变量中。（我甚至不确定这是否是通向任何地方的可行路径，但它似乎是朝着正确方向迈出的一步。）

这是我尝试过的：

int result;

expression =
    term                            [result = _1]
    >> *(   ('+' >> term            [result = result + _1])
        |   ('-' >> term            [result = result - _1])
        );

但是这会让我的编译器（Apple LLVM编译器4.2，Xcode 4.6）发疯，对我大喊

从不兼容的类型“const _1_type”（即“const actor< argument < 0 > >”）分配到“int”

回想起来，当然这很有道理，因为首先_val从未绑定到int（毕竟，解析器应该是通用的）。换句话说，我需要找出如何定义用于临时存储评估解析表达式的类型。

问题是：有人能给我指点方向吗？LHS和RHS的拆分是否是正确的方法？

任何建议都将不胜感激！

- conciliator

顺便说一下，你可以（不推荐）使用 [phoenix::ref(result) = _1] 分配给 result。但是请看我的答案、qi::locals<>以及result变量的生命期/可重入性问题。 - sehe

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- sehe · Accepted Answer

如果你问我，最简单的方法就是：http://liveworkspace.org/code/1fvc8x$0。

equation = (expression >> "=" >> expression) [ _val = _1 == _2 ];

这将解析两个表达式，返回的属性是一个布尔值，指示这两个表达式是否评估为相同的值。

演示程序

int main()
{
    doParse("1 + 2 * 3 = 7");
    doParse("1 + 2 * 3 = 8");
}

打印

parse success
result: true
parse success
result: false

示例程序

#include <boost/fusion/adapted.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>

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

typedef unsigned attr_t;

template <typename It, typename Skipper = qi::space_type>
    struct calculator : qi::grammar<It, bool(), Skipper>
{
    calculator() : calculator::base_type(equation)
    {
        using qi::uint_;
        using qi::_val;
        using qi::_1;
        using qi::_2;

        equation = (expression >> "=" >> expression) [ _val = _1 == _2 ];

        expression =
            term                    [_val = _1]
                >> *( ('+' >> term  [_val = _val + _1])
                    | ('-' >> term  [_val = _val - _1])
                    );

            term =
                factor                [_val = _1]
                >> *( ('*' >> factor  [_val = _val * _1])
                    | ('/' >> factor  [_val = _val / _1])
                    );

            factor =
                uint_                 [_val = _1]
                |   '(' >> expression [_val = _1] >> ')'
                |   ('-' >> factor    [_val = -_1])
                |   ('+' >> factor    [_val = _1]);
    }

  private:
    qi::rule<It, unsigned(), Skipper> expression, term, factor;
    qi::rule<It, bool(), Skipper> equation;
};

bool doParse(const std::string& input)
{
    typedef std::string::const_iterator It;
    auto f(begin(input)), l(end(input));

    calculator<It, qi::space_type> p;
    bool result;

    try
    {
        bool ok = qi::phrase_parse(f,l,p,qi::space,result);
        if (ok)   
        {
            std::cout << "parse success\n";
            std::cout << "result: " << std::boolalpha << result << "\n";
        }
        else      std::cerr << "parse failed: '" << std::string(f,l) << "'\n";

        if (f!=l) std::cerr << "trailing unparsed: '" << std::string(f,l) << "'\n";
        return ok;
    } catch(const qi::expectation_failure<It>& e)
    {
        std::string frag(e.first, e.last);
        std::cerr << e.what() << "'" << frag << "'\n";
    }

    return false;
}

int main()
{
    doParse("1 + 2 * 3 = 7");
    doParse("1 + 2 * 3 = 8");
}