以下代码没有编译错误：
/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";
}
}
}
`
答案 0 :(得分：2)
好吧，就像发生的那样，我正在查看它，并查看SVG规范，并且觉得分享
的一些想法更值得您可能会感兴趣。公平警告：我没有尝试解决您提出的问题。
您似乎已经在基于启发式的解析器框架中“始终自动”运行。有时候事情“不会以正确的方式使事情变得神奇”，我并不感到惊讶。假设您想继续使用Qi，让我们来一个Qi解析器：
#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
注意：
不要与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可以更清晰地模拟原始代码的组织：
#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