c++ - Boost spirit x3 - 惰性解析器

Question

最新的 boost::spirit::x3 是否实现了 lazy 解析器？我在 documentation 中找到了它但在 source code on github 中找不到它并且不能使用 boost::spirit::x3::lazy。我是不是遗漏了什么，或者懒惰的解析器从 spirit 中删除了，或者重命名了，或者其他什么？

Answer 1

我想我会在这里试试我的手。

需要的是围绕迭代器和属性类型进行一些类型删除。这非常接近 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>;

传递惰性主题

现在，我们从哪里“获取”惰性主题？

灵气中，我们有Nabialek Trick .这将使用 qi::locals<>或 inherited attributes ，这基本上都归结为使用 Phoenix 惰性 actor(qi::_r1 或 qi::_a 等)在运行时从解析器上下文中评估一个值。

在 X3 中没有 Phoenix，我们必须自己使用语义操作来操纵上下文。

这个的基本构建 block 是 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 ) 和“执行” ( 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);

        It saved = first;
        x3::skip_over(first, last, ctx);
        if (x3::as_parser(subject).parse(first, last,
                                         std::forward<Ctx>(ctx),
                                         std::forward<RCtx>(rctx), attr)) {
            return true;
        } else {
            first = saved;
            return false;
        }
    }
};

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 ideas in earlier answers

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_lazy_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 do_lazy_type : x3::parser<do_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);

            It saved = first;
            x3::skip_over(first, last, ctx);
            if (x3::as_parser(subject).parse(first, last,
                                             std::forward<Ctx>(ctx),
                                             std::forward<RCtx>(rctx), attr)) {
                return true;
            } else {
                first = saved;
                return false;
            }
        }
    };

    template <typename T> static const as_type<T>       as{};
    template <typename T> static const set_lazy_type<T> set_lazy{};
    template <typename T> static const do_lazy_type<T>  do_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_lazy<Rule>[options] >> ':' >> do_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)

---

¹ 可悲的是文档丢失了