我感到,我必须提及我们,而不是查塔戈。 顺便提一下,我喜欢进行X3轮.演习。
首先,请指出,“精神 Qi”有一个从箱子上靠近的传导器:。
https://coliru.stacked-crooked.com/a/0ad91f352334a2cc”rel=“nofollow noreferer”>Live On Coliru
#include <boost/fusion/adapted.hpp>
#include <boost/fusion/include/io.hpp>
#include <boost/optional/optional_io.hpp>
#include <boost/spirit/include/qi.hpp>
#include <iomanip>
#include <iostream>
namespace qi = boost::spirit::qi;
namespace ast {
struct cmd1 { double param1, param2; };
struct cmd2 { std::string param1; };
using Command = boost::variant<cmd1, cmd2>;
using boost::fusion::operator<<;
} // namespace ast
BOOST_FUSION_ADAPT_STRUCT(ast::cmd1, param1, param2)
BOOST_FUSION_ADAPT_STRUCT(ast::cmd2, param1)
template <typename It> struct CommandParser : qi::grammar<It, ast::Command()> {
CommandParser() : CommandParser::base_type(start) {
using namespace qi;
quoted_string = lexeme[ " >> *~char_( " ) >> " ];
cmd1 = lit("cmd1") >> ((lit("param1") >> = >> double_) ^ //
(lit("param2") >> = >> double_));
cmd2 = lit("cmd2") >> ((lit("param1") >> = >> quoted_string));
start = qi::skip(qi::space)[cmd1 | cmd2];
BOOST_SPIRIT_DEBUG_NODES((cmd1)(cmd2)(start))
}
private:
using Skipper = qi::space_type;
qi::rule<It, ast::Command()> start;
qi::rule<It, ast::cmd1(), Skipper> cmd1;
qi::rule<It, ast::cmd2(), Skipper> cmd2;
qi::rule<It, std::string(), Skipper> quoted_string;
};
template <typename It> boost::optional<ast::Command> parse_line(It first, It last) {
static CommandParser<It> const p;
ast::Command attr;
// if (phrase_parse(first, last, qi::expect[parser::command >> qi::eoi], qi::space, attr))
if (phrase_parse(first, last, p >> qi::eoi, qi::space, attr))
return attr;
return {};
}
auto parse_line(std::string_view input) { return parse_line(begin(input), end(input)); }
int main() {
// for (std::string line; getline(std::cin, line) && !line.empty();) {
for (std::string line :
{
R"()",
R"(cmd1 param1 = 3.14 param2 = 8e-9)",
R"(cmd1 param2 = 8e-9 param1 = 3.14)", // flipped order
R"(cmd1 param1 = 3.14 param2 = -inf)",
R"(cmd1 param2 = -inf param1 = 3.14)", // flipped order
R"(cmd2 param1 = " hello world " )",
// things that would not have parsed with question code:
R"(cmd2 param1 = "" )",
// things that should not parse
R"(cmd2 param1 = 3.14 param2 = 8e-9)",
R"(cmd1 param1 = " hello world " )",
R"(cmd2 param1 = "" trailing rubbish)",
R"(trailing rubbish)",
}) //
{
std::cout << std::left << std::setw(40) << quoted(line);
try {
auto parsed = parse_line(line);
std::cout << " -> " << parsed << std::endl;
} catch (std::exception const& e) {
std::cout << " -> ERROR " << e.what() << std::endl;
}
}
}
印刷
"" -> --
"cmd1 param1 = 3.14 param2 = 8e-9" -> (3.14 8e-09)
"cmd1 param2 = 8e-9 param1 = 3.14" -> (3.14 8e-09)
"cmd1 param1 = 3.14 param2 = -inf" -> (3.14 -inf)
"cmd1 param2 = -inf param1 = 3.14" -> (3.14 -inf)
"cmd2 param1 = " hello world " " -> ( hello world )
"cmd2 param1 = "" " -> ()
"cmd2 param1 = 3.14 param2 = 8e-9" -> --
"cmd1 param1 = " hello world " " -> --
"cmd2 param1 = "" trailing rubbish" -> --
"trailing rubbish" -> --
您可以考虑为此与Qim站在一起。
Other Approaches
为了在X3中找到类似情况,将需要一些英雄。 让我尝试
- ignoring missing or repeated assignments (
cmd1 param1 = 3 param1 = 4 is fine)
- using latest PFR additions for c++20 member name reflection
- dropping the need for/use of Fusion adaptation
Spirit x3: parse into ructs, and specified the worka href=” https://stackoverflow.com/questions/45673378/boost-spirit-x3-parse-into-structs/45683933#comment135826578_45683933" 评论
这里是快速和慷慨的英雄:
namespace detail {
template <typename Attr> auto member_parser = x3::eps;
template <>
auto member_parser<std::string> = x3::rule<struct quoted_string, std::string>{"quoted_string"} =
x3::lexeme[ " >> *~x3::char_( " ) >> " ];
template <> auto member_parser<double> = x3::double_;
template <size_t II, typename T, typename Tuple> auto handle_member(Tuple const& tied) {
auto&& val = std::get<II>(tied);
std::string name{boost::pfr::get_name<II, T>()};
using Attr = std::decay_t<decltype(val)>;
auto assign = [name](auto& ctx) { boost::pfr::get<II>(*x3::get<T>(ctx)) = _attr(ctx); };
return x3::rule<struct _>{name.c_str()} = (x3::lit(name) >> = >> member_parser<Attr>)[assign];
}
template <typename T, typename Tuple, size_t... I>
auto params_impl(Tuple const& tied, std::integer_sequence<size_t, I...>) {
return *(handle_member<I, T, Tuple>(tied) | ...);
}
} // namespace detail
template <typename T> auto make_parser(T const& v = {}) {
std::string tname = boost::typeindex::type_id<T>().pretty_name();
tname = tname.substr(tname.find_last_of(":") + 1);
std::cout << "---- " << tname << std::endl;
auto set_context = [](auto& ctx) { x3::get<T>(ctx) = &_val(ctx); };
return x3::rule<struct _, T>{tname.c_str()} = //
x3::with<T>(static_cast<T*>(nullptr)) //
[x3::eps[set_context] //
>> x3::lit(tname) //
>> detail::params_impl<T>(boost::pfr::structure_tie(v),
std::make_index_sequence<boost::pfr::tuple_size<T>::value>{})];
}
我也许会将其清理起来,使用静态的电动,而不是要求不施工,但为了加快速度,可以保持这种状态。 现在使用:
namespace parser {
auto const command = make_parser<ast::cmd1>() | make_parser<ast::cmd2>();
} // namespace parser
或者说,如果有更多的工厂帮助:
template <typename... Cmd> auto commands() { return (make_parser<Cmd>() | ...); }
auto const command = commands<ast::cmd1, ast::cmd2>();
实例测试案例:
<>Live On Coliru
#include <boost/pfr.hpp>
#include <boost/spirit/home/x3.hpp>
#include <boost/type_index.hpp>
#include <iomanip>
#include <iostream>
#include <optional>
namespace x3 = boost::spirit::x3;
namespace ast {
struct cmd1 { double param1, param2; };
struct cmd2 { std::string param1; };
using Command = boost::variant<cmd1, cmd2>;
} // namespace ast
namespace parser {
namespace detail {
template <typename Attr> auto member_parser = x3::eps;
template <>
auto member_parser<std::string> = x3::rule<struct quoted_string, std::string>{"quoted_string"} =
x3::lexeme[ " >> *~x3::char_( " ) >> " ];
template <> auto member_parser<double> = x3::double_;
template <size_t II, typename T, typename Tuple> auto handle_member(Tuple const& tied) {
auto&& val = std::get<II>(tied);
std::string name{boost::pfr::get_name<II, T>()};
using Attr = std::decay_t<decltype(val)>;
auto assign = [name](auto& ctx) { boost::pfr::get<II>(*x3::get<T>(ctx)) = _attr(ctx); };
return x3::rule<struct _>{name.c_str()} = (x3::lit(name) >> = >> member_parser<Attr>)[assign];
}
template <typename T, typename Tuple, size_t... I>
auto params_impl(Tuple const& tied, std::integer_sequence<size_t, I...>) {
return *(handle_member<I, T, Tuple>(tied) | ...);
}
} // namespace detail
template <typename T> auto make_parser(T const& v = {}) {
std::string tname = boost::typeindex::type_id<T>().pretty_name();
tname = tname.substr(tname.find_last_of(":") + 1);
auto set_context = [](auto& ctx) { x3::get<T>(ctx) = &_val(ctx); };
return x3::rule<struct _, T>{tname.c_str()} = //
x3::with<T>(static_cast<T*>(nullptr)) //
[x3::eps[set_context] //
>> x3::lit(tname) //
>> detail::params_impl<T>(boost::pfr::structure_tie(v),
std::make_index_sequence<boost::pfr::tuple_size<T>::value>{})];
}
template <typename... Cmd> auto commands() { return (make_parser<Cmd>() | ...); }
auto const command = commands<ast::cmd1, ast::cmd2>();
} // namespace parser
template <typename It> std::optional<ast::Command> parse_line(It first, It last) {
ast::Command attr;
// if (phrase_parse(first, last, x3::expect[parser::command >> x3::eoi], x3::space, attr))
if (phrase_parse(first, last, parser::command >> x3::eoi, x3::space, attr))
return attr;
return std::nullopt;
}
auto parse_line(std::string_view input) { return parse_line(begin(input), end(input)); }
int main() {
// for (std::string line; getline(std::cin, line) && !line.empty();) {
for (std::string line :
{
R"()",
R"(cmd1 param1 = 3.14 param2 = 8e-9)",
R"(cmd1 param2 = 8e-9 param1 = 3.14)", // flipped
R"(cmd1 param1 = 3.14 param2 = -inf)",
R"(cmd1 param2 = -inf param1 = 3.14)", // flipped
R"(cmd2 param1 = " hello world " )",
// things that would not have parsed with question code:
R"(cmd2 param1 = "" )",
// things that should not parse
R"(cmd2 param1 = 3.14 param2 = 8e-9)",
R"(cmd1 param1 = " hello world " )",
R"(cmd2 param1 = "" trailing rubbish)",
R"(trailing rubbish)",
}) //
{
std::cout << std::left << std::setw(37) << quoted(line);
try {
if (auto parsed = parse_line(line)) {
apply_visitor(
[](auto const& cmd) {
std::cout << " -> " << boost::typeindex::type_id_runtime(cmd).pretty_name()
<< boost::pfr::io(cmd) << std::endl;
},
*parsed);
} else {
std::cout << " -> --" << std::endl;
}
} catch (std::exception const& e) {
std::cout << " -> ERROR " << e.what() << std::endl;
}
}
}
印刷
"" -> --
"cmd1 param1 = 3.14 param2 = 8e-9" -> ast::cmd1{3.14, 8e-09}
"cmd1 param2 = 8e-9 param1 = 3.14" -> ast::cmd1{3.14, 8e-09}
"cmd1 param1 = 3.14 param2 = -inf" -> ast::cmd1{3.14, -inf}
"cmd1 param2 = -inf param1 = 3.14" -> ast::cmd1{3.14, -inf}
"cmd2 param1 = " hello world " " -> ast::cmd2{" hello world "}
"cmd2 param1 = "" " -> ast::cmd2{""}
"cmd2 param1 = 3.14 param2 = 8e-9" -> --
"cmd1 param1 = " hello world " " -> --
"cmd2 param1 = "" trailing rubbish" -> --
"trailing rubbish" -> --
Summarizing
I would probably make a general grammar and AST like
enum class CmdType { cmd1, cmd2, ... };
using Param = std::string;
using Value = variant<double, std::string>;
using Args = std::multimap<Param, Value>;
struct Cmd {
CmdType cmd;
Args args;
};
And create a validator function that validates the correctness of the commands after parsing. This way you get a very simple grammar that s easy to maintain, and way more flexibility regarding validation logic.
