我的boost :: spirit解析器还有另外一个问题。
template<typename Iterator>
struct expression: qi::grammar<Iterator, ast::expression(), ascii::space_type> {
expression() :
expression::base_type(expr) {
number %= lexeme[double_];
varname %= lexeme[alpha >> *(alnum | '_')];
binop = (expr >> '+' >> expr)[_val = construct<ast::binary_op<ast::add>>(_1,_2)]
| (expr >> '-' >> expr)[_val = construct<ast::binary_op<ast::sub>>(_1,_2)]
| (expr >> '*' >> expr)[_val = construct<ast::binary_op<ast::mul>>(_1,_2)]
| (expr >> '/' >> expr)[_val = construct<ast::binary_op<ast::div>>(_1,_2)] ;
expr %= number | varname | binop;
}
qi::rule<Iterator, ast::expression(), ascii::space_type> expr;
qi::rule<Iterator, ast::expression(), ascii::space_type> binop;
qi::rule<Iterator, std::string(), ascii::space_type> varname;
qi::rule<Iterator, double(), ascii::space_type> number;
};
这是我的解析器。它解析了"3.1415"和"var"就好了，但是当我尝试解析"1+2"时，它会告诉我parse failed。然后我尝试将binop规则更改为
binop = expr >>
(('+' >> expr)[_val = construct<ast::binary_op<ast::add>>(_1, _2)]
| ('-' >> expr)[_val = construct<ast::binary_op<ast::sub>>(_1, _2)]
| ('*' >> expr)[_val = construct<ast::binary_op<ast::mul>>(_1, _2)]
| ('/' >> expr)[_val = construct<ast::binary_op<ast::div>>(_1, _2)]);
但是现在它当然无法构建AST，因为_1和_2设置不同。我只看到_r1之类的内容，但作为一种提升 - 新手，我无法理解boost::phoenix和boost::spirit之间的互动方式。
如何解决这个问题？
答案 0 :(得分：20)
我并不完全清楚你想要实现的目标。最重要的是，你不担心操作员的关联性吗？我只是基于使用右递归来显示简单的答案 - 这会导致左关联运算符被解析。
可见问题的直接答案是兼顾fusion::vector2<char, ast::expression> - 这并不是什么乐趣，尤其是 Phoenix lambda 语义动作。 （我将在下面展示，看起来像什么）。
与此同时，我认为你应该阅读圣经文档
calculator示例，这些示例应该为您提供运算符关联性重要性的提示，以及如何表达捕获二元运算符关联性的语法。显然，它还显示了如何支持括号表达式来覆盖默认评估顺序。我有三个版本的代码可以工作，解析输入如：
std::string input("1/2+3-4*5");
分组为ast::expression（使用BOOST_SPIRIT_DEBUG）：
<expr>
....
<success></success>
<attributes>[[1, [2, [3, [4, 5]]]]]</attributes>
</expr>
代码的链接在这里：
首先，我要删除每个运算符的替代解析表达式;这会导致过度回溯 1 。此外，正如您所发现的，它使语法难以维护。因此，这是一个更简单的变体，它使用一个函数进行语义操作：
<子> 1 检查使用BOOST_SPIRIT_DEBUG！
static ast::expression make_binop(char discriminant,
const ast::expression& left, const ast::expression& right)
{
switch(discriminant)
{
case '+': return ast::binary_op<ast::add>(left, right);
case '-': return ast::binary_op<ast::sub>(left, right);
case '/': return ast::binary_op<ast::div>(left, right);
case '*': return ast::binary_op<ast::mul>(left, right);
}
throw std::runtime_error("unreachable in make_binop");
}
// rules:
number %= lexeme[double_];
varname %= lexeme[alpha >> *(alnum | '_')];
simple = varname | number;
binop = (simple >> char_("-+*/") >> expr)
[ _val = phx::bind(make_binop, qi::_2, qi::_1, qi::_3) ];
expr = binop | simple;
_val 如您所见，这有可能降低复杂性。现在只需要一小步就可以移除binop中间体（这已经变得非常多余）：
number %= lexeme[double_];
varname %= lexeme[alpha >> *(alnum | '_')];
simple = varname | number;
expr = simple [ _val = _1 ]
> *(char_("-+*/") > expr)
[ _val = phx::bind(make_binop, qi::_1, _val, qi::_2) ]
> eoi;
如您所见，
expr规则中，_val延迟占位符用作累积binops的伪局部变量。在整个规则中，您必须使用qi::locals<ast::expression>来实现此类方法。 （这是关于_r1）的问题。expr规则不再需要是自动规则（expr =而非expr %=）最后，为了有趣和血腥，让我展示一下如何处理建议的代码，以及_1，_2等的转换绑定：
static ast::expression make_binop(
const ast::expression& left,
const boost::fusion::vector2<char, ast::expression>& op_right)
{
switch(boost::fusion::get<0>(op_right))
{
case '+': return ast::binary_op<ast::add>(left, boost::fusion::get<1>(op_right));
case '-': return ast::binary_op<ast::sub>(left, boost::fusion::get<1>(op_right));
case '/': return ast::binary_op<ast::div>(left, boost::fusion::get<1>(op_right));
case '*': return ast::binary_op<ast::mul>(left, boost::fusion::get<1>(op_right));
}
throw std::runtime_error("unreachable in make_op");
}
// rules:
expression::base_type(expr) {
number %= lexeme[double_];
varname %= lexeme[alpha >> *(alnum | '_')];
simple = varname | number;
binop %= (simple >> (char_("-+*/") > expr))
[ _val = phx::bind(make_binop, qi::_1, qi::_2) ]; // note _2!!!
expr %= binop | simple;
正如您所看到的那样，编写make_binop函数的方式并不那么有趣！