促进Spirit:如何解析长度在前的字节数组

#define BOOST_SPIRIT_DEBUG
#include <boost/fusion/adapted/struct.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/include/qi.hpp>
#include <vector>
namespace qi = boost::spirit::qi;
typedef unsigned int BYTE;
typedef unsigned long long ULONGLONG;
struct AVLData
{
    ULONGLONG m_timestamp;
    BYTE m_priority;
};
struct AVLDataArray
{
    BYTE m_codecID;
    BYTE m_numOfData;
    std::vector<AVLData> m_data;
    BYTE m_numOfData_last;
};
BOOST_FUSION_ADAPT_STRUCT(AVLDataArray, m_codecID, m_numOfData, m_data,     m_numOfData_last)
template <typename Iterator, typename Skipper = qi::ascii::blank_type>
    struct Grammar: qi::grammar <Iterator, AVLDataArray(), Skipper>
    {
        Grammar() : Grammar::base_type(avl_array)
        {
            qi::uint_parser<BYTE, 16, 2, 2> uint_byte_p;
            qi::uint_parser<unsigned long long, 16, 16, 16> uint_8_byte_p;
            avl_array = uint_byte_p > uint_byte_p[qi::_a = qi::_1] >    qi::repeat(qi::_a)[uint_8_byte_p > uint_byte_p] > uint_byte_p;
            BOOST_SPIRIT_DEBUG_NODES((avl_array));
        }
    private:
        qi::rule<Iterator, AVLDataArray(), Skipper, qi::locals<BYTE>> avl_array;
};
int main() {
    std::string const input = "080100000113fc208dff01";
    auto f(begin(input)), l(end(input));
    Grammar<std::string::const_iterator> g;
    AVLDataArray array;
    bool ok = qi::phrase_parse(f,l,g,qi::blank,array);
    if (ok && f == l) 
    {
        std::cout << "Parse succeededn";
    } else
    {
        std::cout << "Parse failedn";
         std::cout << "->stopped at [" + std::string(f, l) + "]";
    }
    return 0;
}

data = qi::repeat(qi::_a)[uint_8_byte_p > uint_byte_p];
vl_array = uint_byte_p > uint_byte_p[qi::_a = qi::_1] > data > uint_byte_p;

grammar.hpp:75:13: error: static assertion failed: incompatible_start_rule...

第一件事：

grammar.hpp:75:13:错误：静态断言失败：不兼容启动规则。。。

意思是（惊讶）你使用了一个不兼容的开始规则。违规的是语法基类声明中缺少的locals<>参数。与其将该实现细节添加到公共接口，不如考虑使用包装开始规则，该规则调用确实具有locals<>参数的真实解析器入口点。

---

更多：

• m_priority是关于什么的？您的问题没有解决它，样本输入也没有解决它（所以它不应该解析，因为只有8字节的元素，没有优先级）。

• 你忘了改编AVLData了吗？

• 忽略这一点，具有语义操作的规则不会自动传播其属性。这很好，因为您可能不需要AST节点（m_numOfData和m_numOfData_last）中的冗余计数

  您可以使用operator%=而不是operator=来指定规则定义，从而强制自动传播。

• 您可以使用omit从合成属性中省略属性

• 您可能想要验证打开/关闭字节，例如：

  uint_byte_p(0x08)
  

  要检查结束字节是否与第二个匹配，比如：

  qi::omit[uint_byte_p [ qi::_pass = (qi::_a == qi::_1) ] ]
  

  感谢@jv_再次进行双重检查，您确实也可以在那里说omit(uint_byte_p(_a))

• 如果你的语法指定了ascii::blank_type，你就不能为它传递qi::blank。它需要匹配。再次：考虑使用启动规则隐藏队长，而不是公开实现细节。

• 此外，在这个特定的例子中，如果您真的想在输入字符串中的任何地方都接受空格，我会感到惊讶。还要注意，int_parser是隐式的lexeme（这意味着即使在这种配置中，数组元素或字节也不能包含空格）。您应该检查这些是否都符合您的要求。

• 使用期望点实际上排除了解析失败的可能性，没有任何异常（除非第一个字节无法解析，因为第一个uint_byte_p前面没有像qi::eps > uint_byte_p这样的期望点）。考虑使用>>来获得正常的序列语义。

修复这些问题导致工作代码：

在Coliru上直播

//#define BOOST_SPIRIT_DEBUG
#include <boost/fusion/adapted/struct.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/include/qi.hpp>
#include <vector>
#include <iomanip>
namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
typedef unsigned int BYTE; // what large bytes you have, grandma!?
struct AVLData {
    uint64_t m_timestamp;
    BYTE m_priority;
};
struct AVLDataArray {
    BYTE m_codecID;
    std::vector<AVLData> m_data;
};
BOOST_FUSION_ADAPT_STRUCT(AVLData, m_timestamp, m_priority) // you need to adapt all your types
BOOST_FUSION_ADAPT_STRUCT(AVLDataArray, m_codecID, m_data)
template <typename Iterator, typename Skipper = ascii::blank_type>
    struct Grammar: qi::grammar <Iterator, AVLDataArray(), Skipper>
    {
        Grammar() : Grammar::base_type(start)
        {
            qi::uint_parser<BYTE, 16, 2, 2> uint_byte_p;
            qi::uint_parser<uint64_t, 16, 16, 16> uint_8_byte_p;
            avl_array %= uint_byte_p(0x08)
                      >> qi::omit[uint_byte_p[qi::_a = qi::_1]] 
                      >> qi::repeat(qi::_a)[uint_8_byte_p >> uint_byte_p]
                      >> qi::omit[uint_byte_p [ qi::_pass = (qi::_a == qi::_1) ] ]
                      ;
            start      = avl_array;
            BOOST_SPIRIT_DEBUG_NODES((avl_array)(start));
        }
    private:
        qi::rule<Iterator, AVLDataArray(), Skipper> start;
        qi::rule<Iterator, AVLDataArray(), Skipper, qi::locals<BYTE>> avl_array;
};
int main() {
    std::string const input = "080100000113fc208dff" /*priority:*/ "2a" /*end prioirity*/ "01";
    auto f(begin(input)), l(end(input));
    Grammar<std::string::const_iterator> g;
    AVLDataArray array;
    bool ok = qi::phrase_parse(f,l,g,ascii::blank,array);
    if (ok && f == l) 
    {
        std::cout << "Parse succeededn";
        std::cout << "Codec: " << array.m_codecID << "n";
        for(auto& element : array.m_data)
            std::cout << "element: 0x" << std::hex << element.m_timestamp << " prio " << std::dec << element.m_priority << "n";
    } else
    {
        std::cout << "Parse failedn";
        std::cout << "->stopped at [" + std::string(f, l) + "]";
    }
    return 0;
}

打印：

Parse succeeded
Codec: 8
element: 0x113fc208dff prio 42

启用调试信息后：

<start>
  <try>080100000113fc208dff</try>
  <avl_array>
    <try>080100000113fc208dff</try>
    <success></success>
    <attributes>[[8, [[1185345998335, 42]]]]</attributes><locals>(1)</locals>
  </avl_array>
  <success></success>
  <attributes>[[8, [[1185345998335, 42]]]]</attributes>
</start>

奖金：

我可以使用本地跨规则吗？

没有。您需要继承属性：

在Coliru上直播

    data       = qi::repeat(qi::_r1)[uint_8_byte_p >> uint_byte_p]
              ;
    avl_array %= uint_byte_p(0x08)
              >> qi::omit[uint_byte_p[qi::_a = qi::_1]] 
              >> data(qi::_a)
              >> qi::omit[uint_byte_p [ qi::_pass = (qi::_a == qi::_1) ] ]
              ;

规则为：

qi::rule<Iterator, std::vector<AVLData>(BYTE), Skipper> data;
qi::rule<Iterator, AVLDataArray(),             Skipper, qi::locals<BYTE>> avl_array;