Boost spirit x3 - 惰性解析器
Boost spirit x3 - lazy parser
最新的 boost::spirit::x3 是否实现了 lazy 解析器？我在 documentation but cannot find it in source code on github 中找到了它，但无法使用 boost::spirit::x3::lazy。我是不是遗漏了什么或者懒惰的解析器被从 spirit 中删除或者重命名或其他什么？
我想我会在这里尝试一下。
需要的是围绕迭代器和属性类型进行一些类型擦除。这已经非常接近过去qi::rule的界面了。
To be complete we could actually also erase or transform contexts (e.g. to propagate the skipper inside the lazy rule), but I chose for simplicity here.
In many cases the parsers to be lazily invoked might be lexemes anyways (as in the sample I will use)
在我们的用例中，让我们解析这些输入：
integer_value: 42
quoted_string: "hello world"
bool_value: true
double_value: 3.1415926
我们将使用变体属性类型，并从创建一个 lazy_rule 允许我们擦除类型的解析器开始：
using Value = boost::variant<int, bool, double, std::string>;
using It = std::string::const_iterator;
using Rule = x3::any_parser<It, Value>;
传递懒惰的主题
现在，我们"get"懒惰的主题来自哪里？
在灵气中，我们有Nabialek Trick. This would use qi::locals<> or inherited attributes，这基本上都归结为使用凤凰懒演员（qi::_r1或qi::_a等）来计算一个值来自解析器上下文 运行时间。
在 X3 中没有 Phoenix，我们将不得不自己使用语义操作来操纵上下文。
这方面的基本构建块是 x3::with<T>[] directive¹。这是我们最终将用作解析器的内容：
x3::symbols<Rule> options;
现在我们可以将任何解析表达式添加到选项中，例如说options.add("anything", x3::eps);。
auto const parser = x3::with<Rule>(Rule{}) [
set_context<Rule>[options] >> ':' >> lazy<Rule>
];
这给上下文添加了一个Rule值，可以设置(set_context)和"executed"(lazy)。
就像我说的，我们必须手动操作上下文，所以让我们定义一些助手来执行此操作：
template <typename Tag>
struct set_context_type {
template <typename P>
auto operator[](P p) const {
auto action = [](auto& ctx) {
x3::get<Tag>(ctx) = x3::_attr(ctx);
};
return x3::omit [ p [ action ] ];
}
};
template <typename Tag>
struct lazy_type : x3::parser<lazy_type<Tag>> {
using attribute_type = typename Tag::attribute_type; // TODO FIXME?
template<typename It, typename Ctx, typename RCtx, typename Attr>
bool parse(It& first, It last, Ctx& ctx, RCtx& rctx, Attr& attr) const {
auto& subject = x3::get<Tag>(ctx);
return x3::as_parser(subject)
.parse(
first, last,
std::forward<Ctx>(ctx),
std::forward<RCtx>(rctx),
attr);
}
};
template <typename T> static const set_context_type<T> set_context{};
template <typename T> static const lazy_type<T> lazy{};
仅此而已。
演示时间
在此演示中，我们 运行 以上输入（在函数 run_tests() 中），它将使用如下所示的解析器：
auto run_tests = [=] {
for (std::string const& input : {
"integer_value: 42",
"quoted_string: \"hello world\"",
"bool_value: true",
"double_value: 3.1415926",
})
{
Value attr;
std::cout << std::setw(36) << std::quoted(input);
if (phrase_parse(begin(input), end(input), parser, x3::space, attr)) {
std::cout << " -> success (" << attr << ")\n";
} else {
std::cout << " -> failed\n";
}
}
};
首先我们将运行:
options.add("integer_value", x3::int_);
options.add("quoted_string", as<std::string> [
// lexeme is actually redundant because we don't use surrounding skipper yet
x3::lexeme [ '"' >> *('\' >> x3::char_ | ~x3::char_('"')) >> '"' ]
]);
run_tests();
将打印：
"integer_value: 42" -> success (42)
"quoted_string: \"hello world\"" -> success (hello world)
"bool_value: true" -> failed
"double_value: 3.1415926" -> failed
现在，我们可以通过扩展 options:
来演示该解析器的动态特性
options.add("double_value", x3::double_);
options.add("bool_value", x3::bool_);
run_tests();
输出变为：
"integer_value: 42" -> success (42)
"quoted_string: \"hello world\"" -> success (hello world)
"bool_value: true" -> success (true)
"double_value: 3.1415926" -> success (3.14159)
Note, I threw in another helper as<> that makes it easier to coerce the attribute type to std::string there. It's an evolution of
Coliru 上的完整列表
#include <boost/spirit/home/x3.hpp>
#include <iostream>
#include <iomanip>
namespace x3 = boost::spirit::x3;
namespace {
template <typename T>
struct as_type {
template <typename...> struct Tag{};
template <typename P>
auto operator[](P p) const {
return x3::rule<Tag<T, P>, T> {"as"} = x3::as_parser(p);
}
};
template <typename Tag>
struct set_context_type {
template <typename P>
auto operator[](P p) const {
auto action = [](auto& ctx) {
x3::get<Tag>(ctx) = x3::_attr(ctx);
};
return x3::omit [ p [ action ] ];
}
};
template <typename Tag>
struct lazy_type : x3::parser<lazy_type<Tag>> {
using attribute_type = typename Tag::attribute_type; // TODO FIXME?
template<typename It, typename Ctx, typename RCtx, typename Attr>
bool parse(It& first, It last, Ctx& ctx, RCtx& rctx, Attr& attr) const {
auto& subject = x3::get<Tag>(ctx);
return x3::as_parser(subject)
.parse(
first, last,
std::forward<Ctx>(ctx),
std::forward<RCtx>(rctx),
attr);
}
};
template <typename T> static const as_type<T> as{};
template <typename T> static const set_context_type<T> set_context{};
template <typename T> static const lazy_type<T> lazy{};
}
int main() {
std::cout << std::boolalpha << std::left;
using Value = boost::variant<int, bool, double, std::string>;
using It = std::string::const_iterator;
using Rule = x3::any_parser<It, Value>;
x3::symbols<Rule> options;
auto const parser = x3::with<Rule>(Rule{}) [
set_context<Rule>[options] >> ':' >> lazy<Rule>
];
auto run_tests = [=] {
for (std::string const& input : {
"integer_value: 42",
"quoted_string: \"hello world\"",
"bool_value: true",
"double_value: 3.1415926",
})
{
Value attr;
std::cout << std::setw(36) << std::quoted(input);
if (phrase_parse(begin(input), end(input), parser, x3::space, attr)) {
std::cout << " -> success (" << attr << ")\n";
} else {
std::cout << " -> failed\n";
}
}
};
std::cout << "Supporting only integer_value and quoted_string:\n";
options.add("integer_value", x3::int_);
options.add("quoted_string", as<std::string> [
// lexeme is actually redundant because we don't use surrounding skipper yet
x3::lexeme [ '"' >> *('\' >> x3::char_ | ~x3::char_('"')) >> '"' ]
]);
run_tests();
std::cout << "\nAdded support for double_value and bool_value:\n";
options.add("double_value", x3::double_);
options.add("bool_value", x3::bool_);
run_tests();
}
打印完整输出：
Supporting only integer_value and quoted_string:
"integer_value: 42" -> success (42)
"quoted_string: \"hello world\"" -> success (hello world)
"bool_value: true" -> failed
"double_value: 3.1415926" -> failed
Added support for double_value and bool_value:
"integer_value: 42" -> success (42)
"quoted_string: \"hello world\"" -> success (hello world)
"bool_value: true" -> success (true)
"double_value: 3.1415926" -> success (3.14159)
¹ 遗憾的是文档丢失了
最新的 boost::spirit::x3 是否实现了 lazy 解析器？我在 documentation but cannot find it in source code on github 中找到了它，但无法使用 boost::spirit::x3::lazy。我是不是遗漏了什么或者懒惰的解析器被从 spirit 中删除或者重命名或其他什么？
我想我会在这里尝试一下。
需要的是围绕迭代器和属性类型进行一些类型擦除。这已经非常接近过去qi::rule的界面了。
To be complete we could actually also erase or transform contexts (e.g. to propagate the skipper inside the lazy rule), but I chose for simplicity here.
In many cases the parsers to be lazily invoked might be lexemes anyways (as in the sample I will use)
在我们的用例中，让我们解析这些输入：
integer_value: 42
quoted_string: "hello world"
bool_value: true
double_value: 3.1415926
我们将使用变体属性类型，并从创建一个 lazy_rule 允许我们擦除类型的解析器开始：
using Value = boost::variant<int, bool, double, std::string>;
using It = std::string::const_iterator;
using Rule = x3::any_parser<It, Value>;
传递懒惰的主题
现在，我们"get"懒惰的主题来自哪里？
在灵气中，我们有Nabialek Trick. This would use qi::locals<> or inherited attributes，这基本上都归结为使用凤凰懒演员（qi::_r1或qi::_a等）来计算一个值来自解析器上下文 运行时间。
在 X3 中没有 Phoenix，我们将不得不自己使用语义操作来操纵上下文。
这方面的基本构建块是 x3::with<T>[] directive¹。这是我们最终将用作解析器的内容：
x3::symbols<Rule> options;
现在我们可以将任何解析表达式添加到选项中，例如说options.add("anything", x3::eps);。
auto const parser = x3::with<Rule>(Rule{}) [
set_context<Rule>[options] >> ':' >> lazy<Rule>
];
这给上下文添加了一个Rule值，可以设置(set_context)和"executed"(lazy)。
就像我说的，我们必须手动操作上下文，所以让我们定义一些助手来执行此操作：
template <typename Tag>
struct set_context_type {
template <typename P>
auto operator[](P p) const {
auto action = [](auto& ctx) {
x3::get<Tag>(ctx) = x3::_attr(ctx);
};
return x3::omit [ p [ action ] ];
}
};
template <typename Tag>
struct lazy_type : x3::parser<lazy_type<Tag>> {
using attribute_type = typename Tag::attribute_type; // TODO FIXME?
template<typename It, typename Ctx, typename RCtx, typename Attr>
bool parse(It& first, It last, Ctx& ctx, RCtx& rctx, Attr& attr) const {
auto& subject = x3::get<Tag>(ctx);
return x3::as_parser(subject)
.parse(
first, last,
std::forward<Ctx>(ctx),
std::forward<RCtx>(rctx),
attr);
}
};
template <typename T> static const set_context_type<T> set_context{};
template <typename T> static const lazy_type<T> lazy{};
仅此而已。
演示时间
在此演示中，我们 运行 以上输入（在函数 run_tests() 中），它将使用如下所示的解析器：
auto run_tests = [=] {
for (std::string const& input : {
"integer_value: 42",
"quoted_string: \"hello world\"",
"bool_value: true",
"double_value: 3.1415926",
})
{
Value attr;
std::cout << std::setw(36) << std::quoted(input);
if (phrase_parse(begin(input), end(input), parser, x3::space, attr)) {
std::cout << " -> success (" << attr << ")\n";
} else {
std::cout << " -> failed\n";
}
}
};
首先我们将运行:
options.add("integer_value", x3::int_);
options.add("quoted_string", as<std::string> [
// lexeme is actually redundant because we don't use surrounding skipper yet
x3::lexeme [ '"' >> *('\' >> x3::char_ | ~x3::char_('"')) >> '"' ]
]);
run_tests();
将打印：
"integer_value: 42" -> success (42)
"quoted_string: \"hello world\"" -> success (hello world)
"bool_value: true" -> failed
"double_value: 3.1415926" -> failed
现在，我们可以通过扩展 options:
options.add("double_value", x3::double_);
options.add("bool_value", x3::bool_);
run_tests();
输出变为：
"integer_value: 42" -> success (42)
"quoted_string: \"hello world\"" -> success (hello world)
"bool_value: true" -> success (true)
"double_value: 3.1415926" -> success (3.14159)
Note, I threw in another helper
as<>that makes it easier to coerce the attribute type tostd::stringthere. It's an evolution of
Coliru 上的完整列表
#include <boost/spirit/home/x3.hpp>
#include <iostream>
#include <iomanip>
namespace x3 = boost::spirit::x3;
namespace {
template <typename T>
struct as_type {
template <typename...> struct Tag{};
template <typename P>
auto operator[](P p) const {
return x3::rule<Tag<T, P>, T> {"as"} = x3::as_parser(p);
}
};
template <typename Tag>
struct set_context_type {
template <typename P>
auto operator[](P p) const {
auto action = [](auto& ctx) {
x3::get<Tag>(ctx) = x3::_attr(ctx);
};
return x3::omit [ p [ action ] ];
}
};
template <typename Tag>
struct lazy_type : x3::parser<lazy_type<Tag>> {
using attribute_type = typename Tag::attribute_type; // TODO FIXME?
template<typename It, typename Ctx, typename RCtx, typename Attr>
bool parse(It& first, It last, Ctx& ctx, RCtx& rctx, Attr& attr) const {
auto& subject = x3::get<Tag>(ctx);
return x3::as_parser(subject)
.parse(
first, last,
std::forward<Ctx>(ctx),
std::forward<RCtx>(rctx),
attr);
}
};
template <typename T> static const as_type<T> as{};
template <typename T> static const set_context_type<T> set_context{};
template <typename T> static const lazy_type<T> lazy{};
}
int main() {
std::cout << std::boolalpha << std::left;
using Value = boost::variant<int, bool, double, std::string>;
using It = std::string::const_iterator;
using Rule = x3::any_parser<It, Value>;
x3::symbols<Rule> options;
auto const parser = x3::with<Rule>(Rule{}) [
set_context<Rule>[options] >> ':' >> lazy<Rule>
];
auto run_tests = [=] {
for (std::string const& input : {
"integer_value: 42",
"quoted_string: \"hello world\"",
"bool_value: true",
"double_value: 3.1415926",
})
{
Value attr;
std::cout << std::setw(36) << std::quoted(input);
if (phrase_parse(begin(input), end(input), parser, x3::space, attr)) {
std::cout << " -> success (" << attr << ")\n";
} else {
std::cout << " -> failed\n";
}
}
};
std::cout << "Supporting only integer_value and quoted_string:\n";
options.add("integer_value", x3::int_);
options.add("quoted_string", as<std::string> [
// lexeme is actually redundant because we don't use surrounding skipper yet
x3::lexeme [ '"' >> *('\' >> x3::char_ | ~x3::char_('"')) >> '"' ]
]);
run_tests();
std::cout << "\nAdded support for double_value and bool_value:\n";
options.add("double_value", x3::double_);
options.add("bool_value", x3::bool_);
run_tests();
}
打印完整输出：
Supporting only integer_value and quoted_string:
"integer_value: 42" -> success (42)
"quoted_string: \"hello world\"" -> success (hello world)
"bool_value: true" -> failed
"double_value: 3.1415926" -> failed
Added support for double_value and bool_value:
"integer_value: 42" -> success (42)
"quoted_string: \"hello world\"" -> success (hello world)
"bool_value: true" -> success (true)
"double_value: 3.1415926" -> success (3.14159)
¹ 遗憾的是文档丢失了