c++ - 使用凤凰绑定(bind)到结构的提升精神规则 - 编译失败

Question

我想解析以下字符串:id=1;entry1=[A,B,D];entry2=[bla,blubb];factor=[1,5]!

我的解析器:

struct Entry
{
  uint32_t id;
  std::vector< std::string > entry1;
  std::vector< std::string > entry2;

  bool useFactor;
  std::pair<int, int> factor;
};

BOOST_FUSION_ADAPT_STRUCT( Entry, id, entry1, entry2, useFactor, factor)

template<typename It>
struct testParser : qi::grammar<It, Entry()>
{
   testParser : testParser::base_type(start)
   {
     using namespace qi;
     id_ %= lit("id=") >> int_ ;
     entry1_ %= lit("entry1=") >> char_('[') >> +(char_ -char_(']') % ',') >> char_(']');
     entry2_ %= lit("entry1=") >> char_('[') >> +(char_ -char_(']') % ',') >> char_(']');
    factor %= lit("factor=") >> char_('[') >> int_ >> char_(',') >> int_ >> char_(']');

  start = id >> ';' >> entry1 >> ';' >> entry2 >> (( ';' >> factor[ phx::bind(&Entry::useFactor,_1) = true;] ) >> '!') | '!';

   qi::rule<It, Entry()> start;
   qi::rule<It, int()> id;
   qi::rule<It, std::vector<std::string>()> entry1_, entry2_;
   qi::rule<It, std::pair<int,int>()> factor;
}
};

我收到非常大的编译错误消息。我认为这是因为 entry1 和 entry2 规则(字符串插入 vector )

Answer 1

正如您可能在直播中看到的那样，我逐步修正了语法。

其中有很多“你喝醉了”的时刻，所以我不确定我能否在这里捕捉到散文中的基本步骤。无论如何，有 a look at the recorded stream¹ .

一些重要的注释(忽略随机拼写错误和明显混淆的代码):

• 使用 attr(v) 简单地公开一个属性(在本例中为 attr(true))
• 使用 lit('c')、lit("abc") 或仅使用 'c' 和 "abc" 匹配文字字符(字符串)无需捕获其内容
• 仅在存在语义 Action 时使用%=

• 语义在主题解析器成功后运行(并且只有当场成功)。

  因此，即使您应该/应该从语义操作中设置 useFactor 成员，它也只会在 factor 部分存在(和不确定值)的情况下运行否则将被留下)。

• 格式化很重要。

• 调试很重要。

可选:

• 使用 BOOST_SPIRIT_DEBUG* 调试规则
• 使用 as_vector 破解快速打印结果的方法
• 我已经展示了使用 inherited arguments 的技巧因此您可以为 entry1 和 entry2
重用 entry 规则

未显示:

• 使用 skipper 来防止空白
• 使用 no_case 来...不区分大小写
• 使用 skipper:注意 lexeme 以避免在跳过的输入字符之间匹配关键字

工作代码，作为 SSCCE :

Live On Coliru

#define BOOST_SPIRIT_DEBUG
#include <iostream>
#include <vector>

namespace std {
    template <typename T>
    static ostream& operator<<(ostream& os, vector<T> const& v) {
        os << "vector{ ";
        for(auto& e : v)
            os << "'" << e << "', ";
        return os << "}";
    }
    template <typename T, typename U>
    static ostream& operator<<(ostream& os, pair<T,U> const& p) {
        return os << "pair{ '" << p.first << "', '" << p.second << "' }";
    }
}

#include <boost/fusion/adapted/struct.hpp>
#include <boost/fusion/adapted/std_pair.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>

namespace qi = boost::spirit::qi;
namespace phx = boost::phoenix;

struct Entry
{
    uint32_t id;
    std::vector<std::string> entry1;
    std::vector<std::string> entry2;

    bool useFactor;
    std::pair<int, int> factor;
};

BOOST_FUSION_ADAPT_STRUCT(Entry, id, entry1, entry2, useFactor, factor)

template<typename It>
struct testParser : qi::grammar<It, Entry()>
{
    testParser() : testParser::base_type(start)
    {
        using namespace qi;

        id      = "id=" >> int_;
        entry   = lit(_r1) >> ('[' >> +~char_("],") % ',' >> ']');
        factor  = "factor=" >> ('[' >> int_ >> ',' >> int_ >> ']');

        start = 
                id                >> ';' 
             >> entry(+"entry1=") >> ';' 
             >> entry(+"entry2=") >> ';' 
             >> attr(true)  
             >> (factor | attr(std::pair<int,int>{1,1}))
             >> '!';

        BOOST_SPIRIT_DEBUG_NODES((start)(entry)(id)(factor))
#if 0
#endif
    }
  private:
    qi::rule<It, Entry()>                               start;
    qi::rule<It, int()>                                 id;
    qi::rule<It, std::vector<std::string>(std::string)> entry;
    qi::rule<It, std::pair<int,int>()>                  factor;
};

int main() {
    std::string const input = "id=1;entry1=[A,B,D];entry2=[bla,blubb];factor=[1,5]!";
    using It = std::string::const_iterator;

    testParser<It> g;
    It f = input.begin(), l = input.end();

    Entry entry;
    bool ok = qi::parse(f, l, g, entry);

    std::cout << std::boolalpha;
    if (ok) {
        std::cout << "Parsed: " << boost::fusion::as_vector(entry) << "\n";
    } else {
        std::cout << "Parse failed\n";
    }

    if (f!=l)
        std::cout << "Remaining unparsed: '" << std::string(f,l) << "'\n";
}

打印:

<start>
<try>id=1;entry1=[A,B,D];</try>
<id>
    <try>id=1;entry1=[A,B,D];</try>
    <success>;entry1=[A,B,D];entr</success>
    <attributes>[1]</attributes>
</id>
<entry>
    <try>entry1=[A,B,D];entry</try>
    <success>;entry2=[bla,blubb];</success>
    <attributes>[[[A], [B], [D]], [e, n, t, r, y, 1, =]]</attributes>
</entry>
<entry>
    <try>entry2=[bla,blubb];f</try>
    <success>;factor=[1,5]!</success>
    <attributes>[[[b, l, a], [b, l, u, b, b]], [e, n, t, r, y, 2, =]]</attributes>
</entry>
<factor>
    <try>factor=[1,5]!</try>
    <success>!</success>
    <attributes>[[1, 5]]</attributes>
</factor>
<success></success>
<attributes>[[1, [[A], [B], [D]], [[b, l, a], [b, l, u, b, b]], 1, [1, 5]]]</attributes>
</start>
Parsed: (1 vector{ 'A', 'B', 'D', } vector{ 'bla', 'blubb', } true pair{ '1', '5' })

---

¹(我错过了修复标题、平衡括号和向构造函数添加括号等的第一部分……o.O)。