Boost Spirit x3 - 惰性解析器答案

【问题标题】：Boost spirit x3 - lazy parserBoost Spirit x3 - 惰性解析器
【发布时间】：2020-02-11 14:27:40
【问题描述】：

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

【问题讨论】：

github.com/boostorg/spirit/issues/530

标签： c++ boost boost-spirit boost-spirit-x3

【解决方案1】：

我想我会在这里尝试一下。

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

传递懒惰的主题

现在，我们从哪里“得到”惰性主题？

在灵气中，我们有Nabialek Trick。这将使用qi::locals<> 或inherited attributes，它们基本上都归结为使用Phoenix 懒惰的演员（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) 和“执行”(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)

注意，我添加了另一个帮助器as<>，它可以更轻松地将属性类型强制转换为std::string。这是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_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)

¹遗憾的是，文档在行动中丢失了

【讨论】：

你现在正式成为我个人的精神英雄：D
：鞠躬：干杯。我在 Github 问题上发布了概念验证的想法，所以它可能会激发一些更一般的功能想法
哈。使用x3::any_parser 减少了25 行代码（并添加了上下文支持和test-cases）。比较 before 与 after。 /HT @Kojoley 超过 on github。答案已更新。