递归精神.Qi语法的分割错误

Segmentation fault with recursive Spirit.Qi grammar

本文关键字：分割 错误 语法 Qi 递归      更新时间：2023-10-16

我正在尝试为一种非常简单的语言创建一个非常简单的解析器，该语言仅包含数字和数学表达式。最终，我计划扩展它，但直到我能够让这些基本版本工作。

我已经成功解析了：

1
425
1 + 1
1 - 1
1 * 1
1 / 1

没关系。但我想让它递归，比方说，解析输入，比如：

1 + 2 - 3

我开始出现分段错误。我已经在谷歌上搜索了递归语法和分割错误，但我似乎无法将我发现的任何内容应用于此语法以使其工作。这要么是由于它们不适合我的情况，要么是由于我未能正确理解我的气语法发生了什么。

我的语法由以下结构组成（包括融合改编）：

namespace fun_lang {
    namespace qi = boost::spirit::qi;
    namespace ascii = boost::spirit::ascii;
    namespace phoenix = boost::phoenix;
    namespace fusion = boost::fusion;
    struct number_node {
        long value;
    };
    struct operation_node;
    typedef boost::variant<
        boost::recursive_wrapper<operation_node>,
        number_node
    > node;
    struct operation_node {
        node left, right;
        char op;
    };
    struct program {
        std::vector<node> nodes;
    };
}
BOOST_FUSION_ADAPT_STRUCT(fun_lang::program, (std::vector<fun_lang::node>, nodes));
BOOST_FUSION_ADAPT_STRUCT(fun_lang::number_node, (long, value));
BOOST_FUSION_ADAPT_STRUCT(fun_lang::operation_node, (fun_lang::node, left) (char, op) (fun_lang::node, right));
namespace fun_lang {
    template <typename Iterator, typename Skipper>
    struct fun_grammar : qi::grammar<Iterator, program(), Skipper> {
        fun_grammar() : fun_grammar::base_type(start) {
            using ascii::char_;
            using qi::ulong_;
            using qi::_val;
            using qi::_1;
            using phoenix::push_back;
            using phoenix::at_c;
            expression = (integer | operation)[_val = _1];
            oper = (char_('+') | char_('-') | char_('*') | char_('/'))[_val = _1];
            integer = ulong_[at_c<0>(_val) = _1];
            operation = expression[at_c<0>(_val) = _1] >> oper[at_c<1>(_val) = _1] >> expression[at_c<2>(_val) = _1];
            start = *expression[push_back(at_c<0>(_val), _1)];
        }
        qi::rule<Iterator, program(), Skipper> start;
        qi::rule<Iterator, number_node(), Skipper> integer;
        qi::rule<Iterator, char(), Skipper> oper;
        qi::rule<Iterator, node(), Skipper> expression;
        qi::rule<Iterator, operation_node(), Skipper> operation;
    };
}

一些规则结构基于我为另一种语言编写的 yacc 语法，我将其用作构建这些规则的方法的参考。我不确定是什么导致了分段错误，但我知道在运行这个时这就是我收到的。我尝试简化规则，删除一些中间规则，并测试非递归方法。任何非递归的东西似乎都可以工作，但我见过很多 Spirit 的例子，这些例子是成功的，所以我觉得我只是不太明白如何表达这些。

编辑

为了帮助解决问题，您可以在 ideone 上找到一个大致完全相同的副本。ideone 版本与我在本地拥有的版本之间的唯一区别是，它不是直接从标准输入中提取文件，而是读取文件。

堆栈溢出有两个来源（以分段错误告终）。一个是operation_node和node的构造函数。 boost::variant ，当默认构造时，使用其第一个模板参数的默认构造对象进行初始化。这是boost::recursive_wrapper<operation_node>，它构造一个operation_node，它构造两个node，构造一个boost::recursive_wrapper<operation_node>，并且一直持续到堆栈耗尽。

通常给精神语法中的变体一个 nil 类型，如 struct nil { }; 作为第一个参数来防止这种情况，并有一种方法来识别未初始化的变体，所以

struct nil { };
typedef boost::variant<
    nil,
    boost::recursive_wrapper<operation_node>,
    number_node
> node;

将解决此问题。如果不想使用 nil 类型， 

typedef boost::variant<
    number_node,
    boost::recursive_wrapper<operation_node>
> node;

也适用于您的情况，因为number_node可以毫无问题地构建。

另一个堆栈溢出是因为 Boost.Spirit 生成 LL（inf） 解析器（而不是生成 LALR（1） 解析器的 yacc），这意味着你得到的是一个递归下降解析器。规则

expression = (integer | operation)[_val = _1];
operation = expression[at_c<0>(_val) = _1] >> oper[at_c<1>(_val) = _1] >> expression[at_c<2>(_val) = _1];

生成一个解析器，该解析器从operation下降到expression，然后再下降到operation，而不会消耗任何输入。这将递归，直到堆栈溢出，这就是您获得其他段错误的地方。

如果将规则重新表述为 operation

operation = integer[at_c<0>(_val) = _1] >> oper[at_c<1>(_val) = _1] >> expression[at_c<2>(_val) = _1];

这个问题消失了。此外，您必须将expression规则重写为

expression = (operation | integer)[_val = _1];

使匹配按照我认为的预期工作，否则integer部分将在operation有机会找到之前成功匹配，并且解析器不会回溯，因为它具有成功的部分匹配。

另请注意，Spirit 解析器是有属性的;您使用的解析器操作在很大程度上是不必要的。可以像这样重写大部分语法：

expression = operation | integer;
oper = char_("-+*/");
integer = ulong_;
operation = integer >> oper >> expression;
相关文章：