Question

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

我已成功解析：

没问题。但我想让它递归，比如说，解析输入，如：

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语法，我将其用作构造这些规则的方法的参考。我不确定导致分段错误的是什么，但我知道在运行时这是我收到的。我尝试过简化规则，删除一些中间规则，并测试非递归方法。任何不递归的东西似乎都有效，但是我已经看到了很多精神的例子，这些例子都是成功的递归规则所以我觉得我只是不太明白如何表达那些。

修改

为了帮助您解决问题，您可以在ideone找到最准确的副本。 ideone版本与我本地版本之间的唯一区别是，而不是直接从标准输入读取文件。

Answer 1

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

通常将精神语法中的变体赋予类似struct nil { };的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）解析器（而不是yacc，它生成LALR（1）解析器），这意味着你得到的是递归下降解析器。规则

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;

分段错误与递归Spirit.Qi语法

1 个答案: