Я подумал, что попробую свои силы здесь.
Что нужно, так это какое-то стирание типов вокруг итераторов и типов атрибутов. Это очень близко к интерфейсу qi::rule в старые времена.
Чтобы быть полными, мы могли бы на самом деле также стереть или преобразовать контексты (например, для распространения шкипера внутри ленивого правила), но я выбрал для простоты здесь.
Во многих случаях парсеры, которые будут вызываться лениво, в любом случае могут быть лексемами (как в примере, который я буду использовать)
В нашем случае использования давайте разберем эти входные данные:
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>;
Передача Ленивого Субъекта
Теперь, откуда мы "берем" ленивого субъекта?
В Духе Ци у нас был Набиалекский Трюк . При этом будут использоваться qi::locals<> или унаследованные атрибуты , которые в основном сводятся к использованию ленивых актеров Phoenix (qi::_r1 или qi::_a et c) для оценки значения из контекста синтаксического анализатора во время выполнения.
В X3 нет Феникса, и нам придется манипулировать контекстом, используя сами действия semanti c.
Строительный блок basi c для этого это директива x3::with<T>[] ¹. Вот что мы будем использовать в качестве парсера:
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) и "выполнено" (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
Теперь мы можем продемонстрировать динамическую c природу этого синтаксического анализатора, расширив 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)
Обратите внимание, я добавил другого помощника as<>, который упрощает приведение типа атрибута к std::string. Это эволюция идей в предыдущих ответах
Полный список Live On Coliru
Посмотреть Live On 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)
ly К сожалению, документация отсутствует в действии