Question

我正在尝试使用自动规则推导将三个元素分配给一个元组。第二种类型是字符串，第三种类型是字符串向量（第一个参数的类型在此示例中并不那么重要）。

我正在努力理解为什么以下代码无法编译。

#include <boost/fusion/include/std_tuple.hpp>
#include <boost/spirit/include/qi.hpp>

using namespace boost::spirit::qi;
using iterator = std::string::const_iterator;

void qi_compile_test1()
{
    rule<iterator, std::string(), space_type> r_s1, r_s2;
    rule<iterator, std::vector<std::string>(), space_type> r_vec_s1, r_vec_s2;
    rule<iterator, std::tuple<float, std::string, std::vector<std::string>>(), space_type> r;

    r %=
        float_ >
        ((r_s1 > r_vec_s1) |
         (r_s2 > r_vec_s2));
}

错误如下（函数插入是在以字符串作为第二个参数的字符串上调用的）：

/opt/wandbox/boost-1.68.0/clang-6.0.1/include/boost/spirit/home/support/container.hpp:292:15: error: no matching member function for call to 'insert'
            c.insert(c.end(), val);
            ~~^~~~~~
/opt/wandbox/boost-1.68.0/clang-6.0.1/include/boost/spirit/home/support/container.hpp:354:51: note: in instantiation of member function 'boost::spirit::traits::push_back_container<std::__1::basic_string<char>, std::__1::basic_string<char>, void>::call' requested here
        return push_back_container<Container, T>::call(c, val);

简而言之，定义了以下规则：

A > ((B > C) | (B > C))

我怀疑错误源于C与向量相同的事实，可以将其恢复为：

A > ((B > vector) | (B > vector<B))

基于复合属性规则，我假设错误来自以下解决方案：

A > (vector | vector) a : A, b: vector<A> --> (a > b): vector<A> A > vector a : A, b: A --> (a | b): A

由于综合属性是由三个元素组成的元组，因此我希望自动规则可以按顺序保留三种不同类型：

A > ((B > vector) | (B > vector<B)) A > (B > vector) a : A, b: A --> (a | b): A

我不理解的是，以下代码可以编译：

void qi_compile_test2() { rule<iterator, int(), space_type> r_int1, r_int2; rule<iterator, std::vector<int>(), space_type> r_vec_int1, r_vec_int2; rule<iterator, std::tuple<float, int, std::vector<int>>(), space_type> r; r %= float_ > ((r_int1 > r_vec_int1) | (r_int2 > r_vec_int2)); }

唯一的区别是将类型B从std :: string替换为int。我想这简化了事情，因为std :: string是一个容器，而不是'int'类型。在这种情况下，我看不出这种变化会导致什么。

另外，通过取回第一个公式并删除元组的第一个参数，我们可以进行编译（仍然保持替代函数和涉及字符串的相同顺序）。

void qi_compile_test3() { rule<iterator, std::string(), space_type> r_s1, r_s2; rule<iterator, std::vector<std::string>(), space_type> r_vec_s1, r_vec_s2; rule<iterator, std::tuple<std::string, std::vector<std::string>>(), space_type> r; r %= ((r_s1 > r_vec_s1) | (r_s2 > r_vec_s2)); }

我本来希望将等式简化为以下形式，但我认为如果不使用带有lambda的语义动作来使元组变平的方法就无法实现。

void qi_compile_test4() { rule<iterator, std::tuple<std::string, std::vector<std::string>>(), space_type> r_p1, r_p2; rule<iterator, std::tuple<float, std::string, std::vector<std::string>>(), space_type> r; r %= float_ > (r_p1 | r_p2 ); }

此代码可以在这里编译： https://wandbox.org/permlink/iJLRz1TKMK2pWMVb

我要在这里完成的任务是能够使元组的最后两个元素相互依赖。我想保留两个元素的顺序，但用替代功能分开。删除替代函数并仅保留两个语句之一即可编译，但会删除所需的逻辑。

我想避免使用语义动作，因为在我的实际情况下，我的元组包含更多的元素（通过融合枚举的结构），因为一旦我使用语义动作在元组中分配了适当的字段，我就必须分配每个元素。有人对如何解决此问题有任何建议吗？

谢谢

Answer 1

不幸的是，Spirit（Qi和X3）仅合并序列解析器¹的元组。期望解析器的统一表示似乎很自然，但是Spirit并没有深入。它的作用非常简单²，并且修复需要对属性操纵进行大量重构。

但是，一元是透明的，因此float_ >> lexeme[int_ >> char_]的结果为tuple<float, int, char>。

#include <boost/spirit/home/qi.hpp>
#include <boost/core/demangle.hpp>
#include <typeinfo>

namespace qi = boost::spirit::qi;

template <typename Iterator = char const*, typename Context = qi::unused_type, typename Parser>
void print_parser_attr_type(Parser const& p)
{
    using attr_type = typename decltype(boost::spirit::compile<qi::domain>(p))::template attribute<Context, Iterator>::type;
    std::cout << boost::core::demangle(typeid(attr_type).name()) << '\n';
}

int main()
{
    print_parser_attr_type(qi::float_ >> ((qi::int_ >> qi::char_) | (qi::int_ >> qi::char_)));
}

输出：

boost::fusion::vector<float, boost::fusion::vector<int, char> >

float_ >> no_case[int_ >> char_]可以完美地解析为tuple<float, tuple<int, char>>，而float_ >> (int_ >> char_)却不会。

Boost Spirit QI：对元组的自动规则推导，其中包含替代函数中的序列

1 个答案: