9

我正在尝试解析如下的树表达式之类的 C 函数（使用Spirit Parser Framework）：

F( A() , B( GREAT( SOME , NOT ) ) , C( YES ) )

为此，我尝试在以下语法上使用三个规则：

template< typename Iterator , typename ExpressionAST >
struct InputGrammar : qi::grammar<Iterator, ExpressionAST(), space_type> {

    InputGrammar() : InputGrammar::base_type( ) {
       tag = ( qi::char_("a-zA-Z_")  >> *qi::char_("a-zA-Z_0-9") )[ push_back( at_c<0>(qi::_val) , qi::_1 ) ];
       command =  tag [ at_c<0>(qi::_val) = at_c<0>(qi::_1) ] >> "(" >> (*instruction >> ",")
                                        [ push_back( at_c<1>(qi::_val) , qi::_1 ) ]  >> ")";
       instruction = ( command | tag ) [qi::_val = qi::_1];
    }
    qi::rule< Iterator , ExpressionAST() , space_type > tag;
    qi::rule< Iterator , ExpressionAST() , space_type > command;
    qi::rule< Iterator , ExpressionAST() , space_type > instruction;
};

请注意，我的标记规则只是试图捕获表达式中使用的标识符（“函数”名称）。另请注意，标记规则的签名返回 aExpressionAST而不是 a std::string，就像在大多数示例中一样。我想这样做的原因实际上很简单：我讨厌使用变体，如果可能的话我会避免它们。我想保留蛋糕并吃掉它会很棒。

命令应该以标签（当前节点的名称，AST 节点的第一个字符串字段）和括号括起来的可变数量的参数开头，每个参数可以是标签本身或另一个命令。

但是，这个例子根本不起作用。它编译和一切，但在运行时它无法解析我所有的测试字符串。真正让我烦恼的是我不知道如何修复它，因为我无法真正调试上面的代码，至少在这个词的传统含义上是这样。基本上我看到我可以修复上述代码的唯一方法是知道我做错了什么。

所以，问题是我不知道上面的代码有什么问题。您如何定义上述语法？

ExpressionAST我使用的类型是：

struct MockExpressionNode {
    std::string name;
    std::vector< MockExpressionNode > operands;

    typedef std::vector< MockExpressionNode >::iterator iterator;
    typedef std::vector< MockExpressionNode >::const_iterator const_iterator;

    iterator begin() { return operands.begin(); }
    const_iterator begin() const { return operands.begin(); }
    iterator end() { return operands.end(); }
    const_iterator end() const { return operands.end(); }

    bool is_leaf() const {
        return ( operands.begin() == operands.end() );
    }
};

BOOST_FUSION_ADAPT_STRUCT(
    MockExpressionNode,
    (std::string, name)
    (std::vector<MockExpressionNode>, operands)
)
4

1 回答 1

12

就调试而言，可以使用正常的中断和监视方法。但是，您如何格式化规则使这变得困难。如果您按照精神示例进行格式化（~每行一个解析器，每行一个凤凰语句），断点将提供更多信息。

您的数据结构无法区分A()它们SOME都是叶子（如果我遗漏了什么，请告诉我）。从您的变体评论中，我认为这不是您的意图，因此为了区分这两种情况，我bool commandFlag向 MockExpressionNode 添加了一个成员变量（为 true ，为A()false SOME），并带有相应的融合适配器线。

具体到代码，您需要将启动规则传递给基本构造函数，即：

InputGrammar() : InputGrammar::base_type(instruction) {...}

这是语法的入口点，也是您没有得到任何数据解析的原因。我很惊讶没有它编译它，我认为语法类型需要匹配第一条规则的类型。即便如此，这是一个方便遵循的约定。

对于tag规则，实际上有两个解析器qi::char_("a-zA-Z_")，一个是 _1 with type char，*qi::char_("a-zA-Z_0-9")一个是 _2 with type (basically) vector<char>。在没有自动规则的情况下不可能将它们强制转换为字符串，但可以通过将规则附加到每个解析的字符来完成：

tag =   qi::char_("a-zA-Z_")
        [ at_c<0>(qi::_val) = qi::_1 ];
    >> *qi::char_("a-zA-Z_0-9")           //[] has precedence over *, so _1 is 
        [ at_c<0>(qi::_val) += qi::_1 ];  //  a char rather than a vector<char>

但是，让精神进行这种转换要干净得多。所以定义一个新规则：

qi::rule< Iterator , std::string(void) , ascii::space_type > identifier;
identifier %= qi::char_("a-zA-Z_") >> *qi::char_("a-zA-Z_0-9");

不要担心它;)。然后标签变成

tag = identifier
      [
          at_c<0>(qi::_val) = qi::_1,
          ph::at_c<2>(qi::_val) = false //commandFlag
      ]

对于命令，第一部分很好，但是(*instruction >> ",")[ push_back( at_c<1>(qi::_val) , qi::_1 ) ]. 这将解析零个或多个指令规则，后跟一个“，”。它还尝试 push_back a vector<MockExpressionNode>（不知道为什么这也编译了，可能因为缺少启动规则而没有实例化？）。我认为您想要以下内容（带有标识符修改）：

command =
        identifier
        [
           ph::at_c<0>(qi::_val) = qi::_1, 
           ph::at_c<2>(qi::_val) = true    //commandFlag
        ]
    >>  "("
    >> -(instruction % ",")
        [
           ph::at_c<1>(qi::_val) = qi::_1
        ]
    >>  ")";

这里使用了可选操作符-和列表操作符%，后者等价于instruction >> *("," >> instruction). phoenix 表达式然后将向量直接分配给结构成员，但您也可以将操作直接附加到指令匹配并使用 push_back。

指令规则很好，我只提一下它相当于instruction %= (command|tag).

A()最后一件事，如果和之间实际上没有区别SOME（即你的原始结构没有commandFlag），你可以只使用自动规则来编写这个解析器：

template< typename Iterator , typename ExpressionAST >
struct InputGrammar : qi::grammar<Iterator, ExpressionAST(), ascii::space_type> {
   InputGrammar() : InputGrammar::base_type( command ) {
      identifier %=
             qi::char_("a-zA-Z_")
         >> *qi::char_("a-zA-Z_0-9");
      command %=
            identifier
         >> -(
            "("
         >> -(command % ",")
         >>  ")");
    }
    qi::rule< Iterator , std::string(void) , ascii::space_type > identifier;
    qi::rule< Iterator , ExpressionAST(void) , ascii::space_type > command;
};

这是使用紧密模拟输入的融合包装结构的一大好处。

于 2010-06-20T04:20:41.697 回答