Boost.Spirit qi值序列向量

Question

以下代码编译时出错：

/usr/include/boost/spirit/home/qi/detail/assign_to.hpp:153:20: error: no matching conversion for static_cast from 'const char' to 'boost::fusion::vector<char,
      std::vector<double, std::allocator<double> > >'
            attr = static_cast<Attribute>(val);
                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~

我不知道为什么，因为更改为 auto grammar = boost::spirit::no_skip[drawto_commands]; 后它按预期工作。

moveto 和 lineto 解析的类型相同。

Qi 运算符 >> 具有类型规则 a: A, b: vector<A> --> (a >> b): vector<A>，这应该使 drawto_commands 和 moveto_drawto_command_group 解析的类型相同。

我错过了什么？

#include <string>
#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/include/boost_tuple.hpp>

typedef boost::fusion::vector<char, std::vector<double>> Arc;

template <typename P, typename T>
bool test_phrase_parser_attr(const std::string &string, P const& grammar, T& attr, bool full_match = true)
{
    using boost::spirit::qi::phrase_parse;
    using boost::spirit::qi::ascii::space;
    auto f = string.begin();
    auto l = string.end();
    bool match = phrase_parse(f, l, grammar, space, attr);
    return match && (!full_match || (f == l));
}

int main()
{
    using boost::spirit::omit;
    using boost::spirit::qi::ascii::char_;
    using boost::spirit::qi::ascii::space;
    using boost::spirit::qi::attr;
    using boost::spirit::qi::double_;
    using boost::spirit::qi::copy;

    auto wsp = copy(omit[boost::spirit::ascii::space]);
    auto comma_wsp = copy(omit[(char_(',') >> *wsp) | (+wsp >> -char_(',') >> *wsp)]);
    auto coordinate = copy(double_);
    auto coordinate_pair = copy(coordinate >> -comma_wsp >> coordinate);
    auto closepath = copy(char_("Zz") >> attr(std::vector<double>()));
    auto vertical_lineto = copy(char_("Vv") >> *wsp >> (coordinate % -comma_wsp));
    auto lineto = copy(char_("Ll") >> *wsp >> (coordinate_pair % -comma_wsp));
    auto moveto = copy(char_("Mm") >> *wsp >> (coordinate_pair % -comma_wsp));
    auto drawto_command = copy(closepath | vertical_lineto | lineto);
    auto drawto_commands = copy(*(*wsp >> drawto_command >> *wsp));
    auto moveto_drawto_command_group = copy(moveto >> drawto_commands);

    auto grammar = boost::spirit::no_skip[moveto_drawto_command_group];
    std::vector<Arc> attribute;
    std::string str;
    std::cout << "*\n";
    while (getline(std::cin, str))
    {
        if (str.empty())
            break;
        attribute = {};
        bool r = test_phrase_parser_attr(str, grammar, attribute, true);
        if (r)
        {
            std::cout << "Parsing succeeded, got: " << std::endl;
            for (auto &command: attribute){
                char line_type = boost::fusion::at_c<0>(command);
                std::cout << line_type;
                const std::vector<double> arguments = boost::fusion::at_c<1>(command);
                for (size_t i = 0; i < arguments.size(); ++i)
                {
                    std::cout << ' ' << arguments[i];
                }
                std::cout << std::endl;
            }
        }
        else
        {
            std::cout << "Parsing failed\n";
        }
    }
}
`

Answer 1

好的，正如经常发生的那样，我正在查看它和 SVG 规范，只是觉得分享一些想法更值得

1. 风格
2. 齐公约
3. 进阶思路

您可能会感兴趣。公平警告：我并没有尝试解决您提出的问题。

具体说明您的类型

在已经基于启发式的解析器框架中，您似乎“总是自动”。我并不感到惊讶，有时事情“不会以正确的方式变魔术”。假设你想继续使用 Qi，让我们有一个 Qi 解析器：

Live On Coliru

#define BOOST_SPIRIT_DEBUG
#include <string>
#include <iostream>
#include <boost/spirit/home/qi.hpp>
#include <boost/fusion/include/adapt_struct.hpp>

namespace AST {
    using Coordinates = std::vector<double>;

    struct Arc {
        char command;
        Coordinates coordinates;
    };

    using PathData = std::vector<Arc>;
}

BOOST_FUSION_ADAPT_STRUCT(AST::Arc, command, coordinates)

namespace qi = boost::spirit::qi;
namespace Parsers {

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

            opt_comma       = -lit(',');
            coordinate      = double_;
            coordinate_pair = coordinate >> opt_comma >> coordinate;

            moveto          = char_("Mm") >> (coordinate_pair % opt_comma);
            closepath       = char_("Zz") >> attr(AST::Coordinates{});
            vertical_lineto = char_("Vv") >> (coordinate % opt_comma);
            lineto          = char_("Ll") >> (coordinate_pair % opt_comma);
            drawto_command  = closepath | vertical_lineto | lineto;

            drawto_commands = *drawto_command;
            start           = skip(space) [ moveto >> drawto_commands ];


            BOOST_SPIRIT_DEBUG_NODES((opt_comma)(coordinate)(coordinate_pair)
                    (moveto)(closepath)(vertical_lineto)(lineto)(drawto_command)
                    (drawto_commands))
        }
      private:
        using Skipper = qi::space_type;
        qi::rule<It> opt_comma;
        qi::rule<It, double()> coordinate;
        qi::rule<It, AST::Coordinates(), Skipper> coordinate_pair;

        qi::rule<It, AST::Arc(), Skipper> moveto, closepath, vertical_lineto, lineto, drawto_command;
        qi::rule<It, AST::PathData(), Skipper> drawto_commands;

        qi::rule<It, AST::PathData()> start;
    };
}

template <typename P, typename T>
bool test_parse_attr(const std::string &text, P const& grammar, T& attr, bool full_match = true) {
    return parse(text.cbegin(), text.cend(),
            grammar >> (qi::eps(!full_match) | qi::eoi),
            attr);
}

int main() {
    const Parsers::PathData<std::string::const_iterator> grammar;

    for (std::string const str : { "M 100 100 L 300 100 L 200 300 z" }) {
        AST::PathData attribute;
        if (test_parse_attr(str, grammar, attribute, true)) {
            std::cout << "Parsing succeeded, got: " << std::endl;

            for (auto &command: attribute) {
                std::cout << command.command;
                for (auto const& arg : command.coordinates) {
                    std::cout << ' ' << arg;
                }
                std::cout << std::endl;
            }
        } else {
            std::cout << "Parsing failed\n";
        }
    }
}

打印

Parsing succeeded, got: 
M 100 100
L 300 100
L 200 300
z

注意事项：

• Skipper 是解析器的职责，而不是调用者

• 不要干涉fusion::vector（甚至tuple），所以请保持您的代码可维护：

  namespace AST {
      using Coordinates = std::vector<double>;
  
      struct Arc {
          char command;
          Coordinates coordinates;
      };
  
      using PathData = std::vector<Arc>;
  }
  

  后来：

   for (auto &command: attribute) {
        std::cout << command.command;
        for (auto const& arg : command.coordinates) { std::cout << ' ' << arg; }
        std::cout << std::endl;
    }
  

• 它将所有可选的空格匹配到Skipper。我知道这会改变行为（我们会解析“L100,200”，而需要“L 100,200”）。如果您坚持诊断此病例，请说明：

      command_letter  = no_case [ char_(_r1) ] >> &(space|eoi);
      moveto          = command_letter('m') >> (coordinate_pair % opt_comma);
      closepath       = command_letter('z') >> attr(AST::Coordinates{});
      vertical_lineto = command_letter('v') >> (coordinate % opt_comma);
      lineto          = command_letter('l') >> (coordinate_pair % opt_comma);
  

  其中command_letter 是采用继承属性的规则：

  qi::rule<It, char(char)> command_letter;
  

更具体的类型

也许您还想具体说明您的 AST 类型。根据您的领域逻辑，您可能真的不应该将所有参数都视为一个向量。

namespace AST {
    using Coordinate = double;
    using Coordinates = std::vector<Coordinate>;

    struct Point { Coordinate x, y; };
    using Points = std::vector<Point>;

    namespace Cmds {
        struct MoveTo         { Points points; } ;
        struct ClosePath      {                } ;
        struct VerticalLineTo { Coordinates x; } ;
        struct LineTo         { Points points; } ;
    }

    using Cmd = boost::variant<
            Cmds::MoveTo,
            Cmds::ClosePath,
            Cmds::VerticalLineTo,
            Cmds::LineTo
        >;

    using PathData = std::vector<Cmd>;
}

全部改编：

BOOST_FUSION_ADAPT_STRUCT(AST::Point, x, y)
BOOST_FUSION_ADAPT_STRUCT(AST::Cmds::MoveTo, points)
BOOST_FUSION_ADAPT_STRUCT(AST::Cmds::LineTo, points)

您可以考虑使用Nabialek Trick 来解析它们。示例见此处：Parsing a command language using Boost Spirit

更高级的想法

也许使用 X3 可以更清晰地模拟您的原始代码组织：

Live On Coliru

#include <string>
#include <iostream>
#include <boost/spirit/home/x3.hpp>
#include <boost/fusion/include/adapt_struct.hpp>

namespace AST {
    using Coordinates = std::vector<double>;

    struct Arc {
        char command;
        Coordinates coordinates;
    };

    using PathData = std::vector<Arc>;
}

BOOST_FUSION_ADAPT_STRUCT(AST::Arc, command, coordinates)

namespace x3 = boost::spirit::x3;
namespace Parsers {
    using namespace x3;

    auto const opt_comma       = -lit(',');
    auto const coordinate      = double_;
    auto const coordinate_pair = coordinate >> opt_comma >> coordinate;

    template <typename T> auto as = [](auto p) { return rule<struct _, T>{} = p; };

    auto const command_letter  = [](auto p) { return lexeme [ no_case [ char_(p) ] >> &(space|eoi) ]; };
    auto const moveto          = command_letter('m') >> as<AST::Coordinates>(coordinate_pair % opt_comma);
    auto const lineto          = command_letter('l') >> as<AST::Coordinates>(coordinate_pair % opt_comma);
    auto const vertical_lineto = command_letter('v') >> as<AST::Coordinates>(coordinate % opt_comma);
    auto const closepath       = command_letter('z') >> attr(AST::Coordinates{});
    auto const drawto_command  = as<AST::Arc>(closepath | vertical_lineto | lineto);

    auto const drawto_commands = as<AST::PathData>(*drawto_command);
    auto const path_data       = as<AST::PathData>(skip(space) [ moveto >> drawto_commands ]);
}

template <typename P, typename T>
bool test_parse_attr(const std::string &text, P const& grammar, T& attr, bool full_match = true) {
    return parse(
            text.cbegin(), text.cend(),
            grammar >> (x3::eps(!full_match) | x3::eoi),
            attr
        );
}

int main() {
    for (std::string const str : { "M 100 100 L 300 100 L 200 300 z" }) {
        AST::PathData attribute;
        if (test_parse_attr(str, Parsers::path_data, attribute, true)) {
            std::cout << "Parsing succeeded, got: " << std::endl;

            for (auto &command: attribute) {
                std::cout << command.command;
                for (auto const& arg : command.coordinates) {
                    std::cout << ' ' << arg;
                }
                std::cout << std::endl;
            }
        } else {
            std::cout << "Parsing failed\n";
        }
    }
}

也可以打印：

Parsing succeeded, got: 
M 100 100
L 300 100
L 200 300
z