Question

我在解析项目时遇到了麻烦。至少我找到了出现问题的最小代码示例。所以现在尝试解析字符串

＆＃34; bool func1; const bool func2;＆＃34;

这里是最小的示例代码：

namespace qi = boost::spirit::qi;
using qi::lexeme;
using qi::string;
typedef boost::spirit::ascii::space_type TSkipper;

struct MyField
{
    bool isConst;
    std::string mtype;
    std::string name;
};

BOOST_FUSION_ADAPT_STRUCT
    (
    MyField,
    (bool, isConst)
    (std::string, mtype)
    (std::string, name)
    )

void SpiritTestSimple()
{
    qi::rule<std::string::const_iterator, std::string(), TSkipper> valid_symbols;
    qi::rule<std::string::const_iterator, MyField(), TSkipper> field;

    valid_symbols %= lexeme[*qi::char_("a-zA-Z")];

    field %= qi::matches[string("const")] >> valid_symbols >> valid_symbols;

    std::string data = "aaa aaaa; const bbb bbbb;";

    //-----------------------------------------------------------------
    std::string::const_iterator first = data.begin(), last = data.end();
    std::list<MyField> parsed_vals;
    bool is_parsed;
    try
    {
        is_parsed = qi::phrase_parse(   first, last,  
                                        +(field > ';'), 
                                        boost::spirit::ascii::space, parsed_vals);
    }
    catch(const qi::expectation_failure<std::string::const_iterator>& e)
    {
        std::string frag(e.first, e.last);
        std::cout << e.what() << "'" << frag << "'" << std::endl;
    }

    BOOST_ASSERT(is_parsed && "the example not parsed");
}

我写了

+(field > ';')

因为在我的项目中，这个区块可能不存在。每个函数声明必须以＆＃39 ;;＆＃39;结束。当上面的代码示例运行时，我看到引发异常并在控制台中出现了记录：

boost::spirit::qi::expectation_failure''

据我所知 - 在最后一个分号后，解析器尝试解析下一个字段规则并解析了＃34;匹配＆＃34; （因为它在任何情况下都返回值）但是valid_symbols的下一个解析失败了，因为在最后一个分号之后没有数据。所以解析失败了。

如何避免解析在我的情况下失败？

Answer 1

最大的问题是

valid_symbols = qi::lexeme[*qi::char_("a-zA-Z")];

这里的麻烦是它可以匹配空字符串。所以“field”的整个制作可以是一个空字符串。如果您将其更改为（使用qi::alpha作为速记）：

valid_symbols = qi::lexeme[+qi::alpha];

您会发现它确实正确解析了输入。

补充说明：

当你说“我写了+(field > ';')因为在我的项目中这个块可能缺席”这似乎与我相矛盾。如果你想让整个块可选，那你就写了
```
*(field > ';')
```
或者如果你想重复;;我希望
```
*(-field > ';')
```
（或许+(-field > ';')）。
您需要学会使用BOOST_SPIRIT_DEBUG自行查明问题

有关如何使用精神内置调试功能的演示，请参阅完整的工作示例： Live On Coliru

#define BOOST_SPIRIT_DEBUG
#include <boost/fusion/adapted/struct.hpp>
#include <boost/spirit/include/qi.hpp>

namespace qi = boost::spirit::qi;
typedef boost::spirit::ascii::space_type TSkipper;

struct MyField
{
    bool isConst;
    std::string mtype;
    std::string name;
};

BOOST_FUSION_ADAPT_STRUCT
    (
     MyField,
     (bool, isConst)
     (std::string, mtype)
     (std::string, name)
    )

template <typename It, typename TSkipper = boost::spirit::ascii::space_type>
struct MyGrammar : qi::grammar<It, std::list<MyField>(), TSkipper>
{
    MyGrammar() : MyGrammar::base_type(start) {
        valid_symbols = qi::lexeme[+qi::alpha];
        field         = qi::matches[qi::string("const")] >> valid_symbols >> valid_symbols;
        start         = +(field > ";");

        BOOST_SPIRIT_DEBUG_NODES((valid_symbols)(field)(start))
    }
  private:
    qi::rule<std::string::const_iterator, std::string(),        TSkipper> valid_symbols;
    qi::rule<std::string::const_iterator, MyField(),            TSkipper> field;
    qi::rule<std::string::const_iterator, std::list<MyField>(), TSkipper> start;
};

int main()
{
    std::string const data = "aaa aaaa; const bbb bbbb;";

    //-----------------------------------------------------------------
    std::string::const_iterator first = data.begin(), last = data.end();
    std::list<MyField> parsed_vals;

    bool is_parsed = false;

    try
    {
        MyGrammar<std::string::const_iterator> grammar;

        is_parsed = qi::phrase_parse(   first, last,  
                                        grammar, 
                                        boost::spirit::ascii::space, 
                                        parsed_vals);
    }
    catch(const qi::expectation_failure<std::string::const_iterator>& e)
    {
        std::string frag(e.first, e.last);
        std::cout << "Expectation failure: " << e.what() << " at '" << frag << "'" << std::endl;
    }

    BOOST_ASSERT(is_parsed && "the example not parsed");
}

打印哪些：

<start>
<try>aaa aaaa; const bbb </try>
<field>
    <try>aaa aaaa; const bbb </try>
    <valid_symbols>
    <try>aaa aaaa; const bbb </try>
    <success> aaaa; const bbb bbb</success>
    <attributes>[[a, a, a]]</attributes>
    </valid_symbols>
    <valid_symbols>
    <try> aaaa; const bbb bbb</try>
    <success>; const bbb bbbb;</success>
    <attributes>[[a, a, a, a]]</attributes>
    </valid_symbols>
    <success>; const bbb bbbb;</success>
    <attributes>[[0, [a, a, a], [a, a, a, a]]]</attributes>
</field>
<field>
    <try> const bbb bbbb;</try>
    <valid_symbols>
    <try> bbb bbbb;</try>
    <success> bbbb;</success>
    <attributes>[[b, b, b]]</attributes>
    </valid_symbols>
    <valid_symbols>
    <try> bbbb;</try>
    <success>;</success>
    <attributes>[[b, b, b, b]]</attributes>
    </valid_symbols>
    <success>;</success>
    <attributes>[[1, [b, b, b], [b, b, b, b]]]</attributes>
</field>
<field>
    <try></try>
    <valid_symbols>
    <try></try>
    <fail/>
    </valid_symbols>
    <fail/>
</field>
<success></success>
<attributes>[[[0, [a, a, a], [a, a, a, a]], [1, [b, b, b], [b, b, b, b]]]]</attributes>
</start>

boost :: spirit :: qi匹配[]麻烦

1 个答案: