Boost C++ 库

首先，让我们介绍一下将在整个文档中使用的术语。

一个 语义动作 是一个与解析器关联的任意逻辑片段，它仅在解析器匹配时执行。

更简单的解析器可以组合成更复杂的解析器。给定一个组合操作 C，以及解析器 P0、P1、... PN，C(P0, P1, ... PN) 创建一个新的解析器 Q。这创建了一个 解析树。 Q 是 P1 的父节点，P2 是 Q 的子节点，依此类推。解析器按照此拓扑结构隐含的从上到下的方式进行应用。当您使用 Q 解析字符串时，它将使用 P0、P1 等来执行实际工作。如果 P3 正在用于解析输入，这意味着 Q 也在这样做，因为 Q 的解析方式是通过分派到其子项来执行部分或全部工作。在解析的任何一点，将只有一个没有子项的解析器被用于解析输入；所有其他正在使用的解析器都是解析树中的祖先。

一个 子解析器 是另一个解析器的子解析器。

顶级解析器 是解析器树的根。

当前解析器 或 最底层解析器 是当前正在用于解析输入的、没有子项的解析器。

一个 规则 是一种解析器，它使构建大型、复杂的解析器变得更容易。一个 子规则 是一个属于其他规则的规则。 当前规则 或 最底层规则 是当前用于解析输入且没有子规则的那个规则。请注意，虽然总是只有一个当前解析器，但可能有一个当前规则，也可能没有——规则是一种解析器，您在解析的特定点可能正在使用它，也可能没有。

顶级解析 是由顶级解析器执行的解析操作。这个术语是必要的，因为虽然大多数解析失败都是局部的，但有些解析失败会导致 parse() 调用指示整个解析失败。在这些情况下，我们说这种局部失败“导致顶级解析失败”。

在整个 Boost.Parser 文档中，我将引用“调用 parse()”。将其读作“调用 The parse() API 中描述的任何一个函数”。这包括 prefix_parse()、callback_parse() 和 callback_prefix_parse()。

文档中经常出现几种特殊的解析器。

一种是 序列解析器；您会看到它使用 operator>> 创建，如 p1 >> p2 >> p3 所示。序列解析器尝试按顺序匹配其所有子解析器到输入。只有当其所有子解析器都匹配时，它才匹配输入。

另一种是 选择解析器；您会看到它使用 operator| 创建，如 p1 | p2 | p3 所示。选择解析器尝试按顺序匹配其所有子解析器到输入；它最多匹配一个子解析器后停止。只有当其一个子解析器匹配时，它才匹配输入。

最后，还有一个 排列解析器；它使用 operator|| 创建，如 p1 || p2 || p3 所示。排列解析器尝试按任意顺序匹配其所有子解析器到输入。所以解析器 p1 || p2 || p3 等价于 (p1 >> p2 >> p3) | (p1 >> p3 >> p2) | (p2 >> p1 >> p3) | (p2 >> p3 >> p1) | (p3 >> p1 >> p2) | (p3 >> p2 >> p1)。希望它的简洁性优势不言而喻。它匹配输入当且仅当其所有子解析器都匹配，无论它们的匹配顺序如何。

Boost.Parser 解析器都有一个与之关联的 属性，或者明确地没有属性。属性是解析器在匹配输入时生成的值。例如，解析器 double_ 在匹配输入时生成一个 double。 ATTR() 是一个概念上的宏，它会展开为传递给它的解析器的属性类型； ATTR(double_) 是 double。这类似于 attribute 类型特征。

接下来，我们将研究一些使用 Boost.Parser 进行解析的简单程序。我们将从小处着手，然后逐步深入。

这是几乎可以用尽的最精简的 Boost.Parser 使用示例。我们从命令行获取一个字符串，如果没有则默认为“World”，然后对其进行解析。

#include <boost/parser/parser.hpp>

#include <iostream>
#include <string>


namespace bp = boost::parser;

int main(int argc, char const * argv[])
{
    std::string input = "World";
    if (1 < argc)
        input = argv[1];

    std::string result;
    bp::parse(input, *bp::char_, result);
    std::cout << "Hello, " << result << "!\n";
}

表达式 *bp::char_ 是一个解析器表达式。它使用了 Boost.Parser 提供的众多解析器之一：char_。与所有 Boost.Parser 解析器一样，它具有某些已定义的运算符。在这种情况下，*bp::char_ 使用了重载的 operator* 作为 Kleene star 运算符的 C++ 版本。由于 C++ 没有后缀一元 * 运算符，我们必须使用我们拥有的那个，所以它被用作前缀。

所以，*bp::char_ 意味着“任意数量的字符”。换句话说，它实际上不会失败。即使是空字符串也会匹配它。

解析操作是通过调用 parse() 函数来执行的，将解析器作为参数之一传递。

bp::parse(input, *bp::char_, result);

这里的参数是：input，要解析的范围；*bp::char_，用于执行解析的解析器；以及 result，一个输出参数，用于存放解析结果。不要过分纠结于这种从 parse() 中获取解析结果的方法；有多种方法可以做到这一点，我们将在后续章节中全部介绍。

另外，暂时忽略 Boost.Parser 如何推断出 *bp::char_ 解析器的结果类型是 std::string。这背后有明确的规则，我们稍后会讨论。

这次 parse() 调用的效果并不有趣——由于我们传入的解析器永远不会失败，而且我们正在将输出放置在与输入相同的类型中，它只是将 input 的内容复制到 result。

让我们来看一个稍微复杂一些的例子，即使它仍然很简单。我们不接受任意字符，而是要求一定的结构。我们解析一个或多个 double，以逗号分隔。

Boost.Parser 中表示 double 的解析器是 double_。所以，要解析一个 double，我们只需使用它。如果我们想连续解析两个 double，我们会这样做：

boost::parser::double_ >> boost::parser::double_

此表达式中的 operator>> 是序列运算符；读作“后面跟着”。如果我们结合序列运算符和 Kleene star，我们可以通过编写来获得我们想要的解析器：

boost::parser::double_ >> *(',' >> boost::parser::double_)

这是一个匹配至少一个 double 的解析器——因为上面表达式中的第一个 double_——后面跟着零个或多个“逗号后面跟着一个 double”的实例。请注意，我们可以直接使用 ','。虽然它不是一个解析器，但 operator>> 和 Boost.Parser 解析器上定义的其他运算符接受字符/解析器对参数；这些运算符重载将创建正确的解析器来识别 ','。

#include <boost/parser/parser.hpp>

#include <iostream>
#include <string>


namespace bp = boost::parser;

int main()
{
    std::cout << "Enter a list of doubles, separated by commas.  No pressure. ";
    std::string input;
    std::getline(std::cin, input);

    auto const result = bp::parse(input, bp::double_ >> *(',' >> bp::double_));

    if (result) {
        std::cout << "Great! It looks like you entered:\n";
        for (double x : *result) {
            std::cout << x << "\n";
        }
    } else {
        std::cout
            << "Good job!  Please proceed to the recovery annex for cake.\n";
    }
}

第一个示例填充了一个输出参数来传递解析结果。这个 parse() 调用返回一个结果。正如您所见，该结果在上下文中可转换为 bool，而 *result 是某种范围。事实上，这次 parse() 调用的返回类型是 std::optional<std::vector<double>>。当然，如果解析失败，将返回 std::nullopt。我们稍后会看 Boost.Parser 如何将解析器的类型映射到返回类型或填充的输出参数的类型。

如果在 shell 中运行它，结果是这样的：

$ example/trivial
Enter a list of doubles, separated by commas.  No pressure. 5.6,8.9
Great! It looks like you entered:
5.6
8.9
$ example/trivial
Enter a list of doubles, separated by commas.  No pressure. 5.6, 8.9
Good job!  Please proceed to the recovery annex for cake.

它不识别 "5.6, 8.9"。这是因为期望一个紧跟着 立即 一个 double 的逗号，但我却在逗号后面加了一个空格。如果我在逗号前面，或者在 double 列表的前后加空格，也会发生同样的解析失败。

还有一点：有一个更好的方法来编写上面的解析器。与其重复 double_ 子解析器，我们本可以这样写：

bp::double_ % ','

这在语义上等同于 bp::double_ >> *(',' >> bp::double_)。这种模式——某个输入部分重复一次或多次，每次之间都有一个分隔符——非常常见，以至于有一个专门的操作符 operator%。从现在开始，我们将使用该运算符。

让我们修改一下刚才看到的简单解析器，使其能够忽略它在 doubles 和逗号之间可能找到的任何空格。为了在找到空格时跳过它，我们可以将一个 跳过解析器 传递给我们的 parse() 调用（我们不需要更改传递给 parse() 的解析器）。在这里，我们使用 ws，它匹配任何 Unicode 空白字符。

#include <boost/parser/parser.hpp>

#include <iostream>
#include <string>


namespace bp = boost::parser;

int main()
{
    std::cout << "Enter a list of doubles, separated by commas.  No pressure. ";
    std::string input;
    std::getline(std::cin, input);

    auto const result = bp::parse(input, bp::double_ % ',', bp::ws);

    if (result) {
        std::cout << "Great! It looks like you entered:\n";
        for (double x : *result) {
            std::cout << x << "\n";
        }
    } else {
        std::cout
            << "Good job!  Please proceed to the recovery annex for cake.\n";
    }
}

跳过解析器，或 skipper，在 parse() 调用传入的解析器中的子解析器之间运行。在此示例中，skipper 在解析第一个 double 之前运行，在解析任何后续逗号或 double 之前运行，并在最后运行。因此，字符串 "3.6,5.9" 和 " 3.6 , \t 5.9 " 被此程序解析为相同。

跳过是 Boost.Parser 中的一个重要概念。您可以跳过任何内容，而不仅仅是空白；还有许多其他您可能想跳过的内容。传递给 parse() 的 skipper 可以是任意解析器。例如，如果您编写了一个脚本语言的解析器，您可以编写一个 skipper 来跳过空格、行内注释和行尾注释。

在文档的其余部分，我们将几乎专门使用跳过解析器。忽略输入中您不关心的部分的能力非常方便，以至于实际上很少会进行不跳过的解析。

与所有解析系统（lex & yacc、Boost.Spirit 等）一样，Boost.Parser 提供了一种机制，用于将语义动作与解析的不同部分关联起来。这是一个几乎与上一个示例相同的程序，不同之处在于它基于一个语义动作来实现，该动作将每个解析出的 double 追加到结果中，而不是自动构建并返回结果。要做到这一点，我们将上一个示例中的 double_ 替换为 double_[action]； action 是我们的语义动作。

#include <boost/parser/parser.hpp>

#include <iostream>
#include <string>


namespace bp = boost::parser;

int main()
{
    std::cout << "Enter a list of doubles, separated by commas. ";
    std::string input;
    std::getline(std::cin, input);

    std::vector<double> result;
    auto const action = [&result](auto & ctx) {
        std::cout << "Got one!\n";
        result.push_back(_attr(ctx));
    };
    auto const action_parser = bp::double_[action];
    auto const success = bp::parse(input, action_parser % ',', bp::ws);

    if (success) {
        std::cout << "You entered:\n";
        for (double x : result) {
            std::cout << x << "\n";
        }
    } else {
        std::cout << "Parse failure.\n";
    }
}

在 shell 中运行，它看起来是这样的：

$ example/semantic_actions
Enter a list of doubles, separated by commas. 4,3
Got one!
Got one!
You entered:
4
3

在 Boost.Parser 中，语义动作是通过可调用对象实现的，这些对象接受一个解析上下文对象作为参数。解析上下文对象表示解析的当前状态。在示例中，我们使用了这个 lambda 作为我们的可调用对象：

auto const action = [&result](auto & ctx) {
    std::cout << "Got one!\n";
    result.push_back(_attr(ctx));
};

我们既向 std::cout 打印消息，又在 lambda 中记录了解析结果。如果您愿意，它可以执行所有这些操作，其中任何一项，或都不执行。我们通过询问解析上下文来获取 lambda 中的已解析 double。 _attr(ctx) 是如何从解析上下文获取与语义动作关联的解析器产生的属性。有许多函数，如 _attr()，可用于访问解析上下文中的状态。我们将在稍后介绍更多内容。The Parse Context 定义了解析上下文的确切内容及其工作方式。

请注意，您不能直接将未修饰的 lambda 写入语义动作。否则，编译器会看到两个 '[' 字符，并认为它即将解析一个属性。括号可以解决这个问题：

p[([](auto & ctx){/*...*/})]

在执行此操作之前，请注意，您作为语义动作编写的 lambda 几乎总是通用的（具有 auto & ctx 参数），因此它们非常可重用。您编写的大多数语义动作 lambda 都应该在行外编写，并给予一个好的名称。即使它们不被重用，命名 lambda 也能使您的解析器更小、更易读。

规则内部的语义动作

当在 rules 中使用语义动作时，还有其他一些形式。请参阅 More About Rules 获取详细信息。

到目前为止，我们已经看到了一些解析文本并生成相关属性的示例。有时，您想找到输入中的某个子范围，其中包含您正在寻找的内容，并且您不想生成任何属性。

有两个 指令 会影响任何解析器的属性类型：raw[] 和 string_view[]。（我们将在后面的“指令”部分更详细地介绍指令。目前，您只需要知道指令包装了解析器，并改变了它的某些功能方面。）

raw[]

raw[] 将其解析器的属性更改为 subrange，其 begin() 和 end() 返回与 p 匹配的被解析序列的边界。

namespace bp = boost::parser;
auto int_parser = bp::int_ % ',';            // ATTR(int_parser) is std::vector<int>
auto subrange_parser = bp::raw[int_parser];  // ATTR(subrange_parser) is a subrange

// Parse using int_parser, generating integers.
auto ints = bp::parse("1, 2, 3, 4", int_parser, bp::ws);
assert(ints);
assert(*ints == std::vector<int>({1, 2, 3, 4}));

// Parse again using int_parser, but this time generating only the
// subrange matched by int_parser.  (prefix_parse() allows matches that
// don't consume the entire input.)
auto const str = std::string("1, 2, 3, 4, a, b, c");
auto first = str.begin();
auto range = bp::prefix_parse(first, str.end(), subrange_parser, bp::ws);
assert(range);
assert(range->begin() == str.begin());
assert(range->end() == str.begin() + 10);

static_assert(std::is_same_v<
              decltype(range),
              std::optional<bp::subrange<std::string::const_iterator>>>);

请注意，subrange 的迭代器类型是 std::string::const_iterator，因为这是传递给 prefix_parse() 的迭代器类型。如果我们向 prefix_parse() 传递了 char const * 迭代器，那将是迭代器类型。唯一的例外来自 Unicode 感知解析（请参阅“Unicode 支持”）。在其中一些情况下，解析中使用的迭代器不是您传递的那个。例如，如果您使用 char8_t * 迭代器调用 prefix_parse()，它将创建一个 UTF-8 到 UTF-32 的转码视图，并解析该视图的迭代器。在这种情况下，您将获得一个 subrange，其迭代器类型是转码迭代器。当这种情况发生时，您可以通过调用返回的 subrange 中的每个转码迭代器上的 .base() 成员函数来获取底层迭代器——您传递给 prefix_parse() 的那个。

auto const u8str = std::u8string(u8"1, 2, 3, 4, a, b, c");
auto u8first = u8str.begin();
auto u8range = bp::prefix_parse(u8first, u8str.end(), subrange_parser, bp::ws);
assert(u8range);
assert(u8range->begin().base() == u8str.begin());
assert(u8range->end().base() == u8str.begin() + 10);

string_view[]

string_view[] 的语义与 raw[] 非常相似，只是它产生的是 std::basic_string_view<CharT>（其中 CharT 是被解析的底层范围的类型），而不是 subrange。为了实现这一点，底层范围必须是连续的。迭代器的连续性在 C++20 之前是无法检测的，因此此指令仅在 C++20 及更高版本中可用。

namespace bp = boost::parser;
auto int_parser = bp::int_ % ',';              // ATTR(int_parser) is std::vector<int>
auto sv_parser = bp::string_view[int_parser];  // ATTR(sv_parser) is a string_view

auto const str = std::string("1, 2, 3, 4, a, b, c");
auto first = str.begin();
auto sv1 = bp::prefix_parse(first, str.end(), sv_parser, bp::ws);
assert(sv1);
assert(*sv1 == str.substr(0, 10));

static_assert(std::is_same_v<decltype(sv1), std::optional<std::string_view>>);

由于 string_view[] 产生 string_view，它不能像上面为 raw[] 描述的那样返回转码迭代器。如果您使用 string_view[] 解析 CharT 序列，您将获得一个 std::basic_string_view<CharT>。如果解析在使用 Unicode 感知路径中的转码，string_view[] 将在必要时分解转码迭代器。如果您将转码视图传递给 parse() 或将转码迭代器传递给 prefix_parse()，string_view[] 仍能毫无问题地看到转码迭代器，并为您提供底层范围一部分的 string_view。

auto sv2 = bp::parse("1, 2, 3, 4" | bp::as_utf32, sv_parser, bp::ws);
assert(sv2);
assert(*sv2 == "1, 2, 3, 4");

static_assert(std::is_same_v<decltype(sv2), std::optional<std::string_view>>);

现在是时候详细描述解析上下文了。您编写的任何语义动作都需要使用解析上下文中的状态，因此您需要了解可用的内容。

解析上下文是一个对象，它存储解析的当前状态——当前迭代器和结束迭代器、错误处理程序等。在解析的不同时间，数据似乎被“添加到”它或“从中删除”。例如，当一个具有语义动作 a 的解析器 p 成功时，上下文会将 p 生成的属性添加到解析上下文中，然后调用 a，并将上下文传递给它。

尽管上下文对象似乎有东西被添加或删除，但事实并非如此。实际上，没有一个单独的上下文对象。上下文在解析期间的各种时间形成，通常是在开始子解析器时。每个上下文都是通过获取前一个上下文并根据需要添加或更改成员来形成新的上下文对象而创建的。当包含新上下文对象的函数返回时，其上下文对象（如果有）将被销毁。这样做效率很高，因为解析上下文只有大约十几个数据成员，每个数据成员的大小都不大于指针。因此，在修改上下文时复制整个上下文是快速的。上下文不进行内存分配。

始终可用的数据的访问器

按照惯例，所有接受解析上下文并且因此 intended for use inside semantic actions 的 Boost.Parser 函数的名称都以一个下划线开头。

_pass()

_pass() 返回一个对 bool 的引用，该引用指示当前解析的成功或失败。这可以用来强制当前解析通过或失败。

[](auto & ctx) {
    // If the attribute fails to meet this predicate, fail the parse.
    if (!necessary_condition(_attr(ctx)))
        _pass(ctx) = false;
}

请注意，要执行语义动作，其关联的解析器必须已经成功。所以，除非您之前在动作中编写了 _pass(ctx) = false，否则 _pass(ctx) = true 不会起任何作用；它是多余的。

_begin(), _end() and _where()

_begin() 和 _end() 分别返回您传递给 parse() 的范围的开始和结束。 _where() 返回一个 subrange，指示当前解析匹配的输入的边界。如果您只想解析某些文本并返回一个由某些元素位置组成的结果，而不产生任何其他属性，则 _where() 会很有用。 _where() 在跟踪元素位置以在解析的后续阶段提供良好的诊断信息方面也至关重要。想象一下 XML 中的标签不匹配；如果您在元素末尾解析了闭合标签，并且它与开始标签不匹配，您希望生成一条提及或显示两个标签的错误消息。将 _where(ctx).begin() 存储在闭合标签解析器可用的地方，将有助于此。有关此示例，请参阅“错误处理和调试”。

_error_handler()

_error_handler() 返回一个对传递给 parse() 的解析器关联的错误处理程序的引用。使用 _error_handler()，您可以在语义动作中生成错误和警告。有关具体示例，请参阅“错误处理和调试”。

有时才可用的数据的访问器

_attr()

_attr() 返回当前解析器属性值的引用。仅当当前解析器成功解析时才可用。如果解析器没有语义动作，则不会将属性添加到解析上下文中。它可用于读取和写入当前解析器的属性。

[](auto & ctx) { _attr(ctx) = 3; }

如果当前解析器没有属性，则返回 none。

_val()

_val() 返回当前用于解析的规则的属性值的引用（如果存在），即使在规则解析成功之前也可用。它可以用于设置当前规则的属性，即使是从规则内的子解析器。假设我们正在编写一个具有语义动作的解析器，该语义动作位于一个规则内。如果我们想将当前规则的值设置为子解析器属性的某个函数，我们将这样编写语义动作：

[](auto & ctx) { _val(ctx) = some_function(_attr(ctx)); }

如果没有当前规则，或者当前规则没有属性，则返回 none。

您需要在 rule 解析器的默认属性类型与 rule 的属性类型不直接兼容的情况下使用 _val()。在这些情况下，您需要编写像上面的示例那样的代码来从规则解析器的已生成属性计算规则的属性。有关 rules 的更多信息，请参阅下一页和“更多关于规则”。

_globals()

_globals() 返回一个对用户提供的对象的引用，该对象包含您想在解析过程中使用的任何数据。“parse 的全局变量”是一个对象——通常是一个结构体——您将其提供给顶级解析器。然后，您可以在解析过程中的任何时候使用 _globals() 来访问它。我们将在“The parse() API”中看到全局变量如何与顶级解析器相关联。例如，假设您的解析有一个早期部分需要记录一些黑名单值，并且解析的后续部分可能需要解析值，如果看到黑名单值则解析失败。在解析的早期部分，您可以编写如下代码。

[](auto & ctx) {
    // black_list is a std::unordered_set.
    _globals(ctx).black_list.insert(_attr(ctx));
}

然后在解析的后期，您可以使用 black_list 来检查解析的值。

[](auto & ctx) {
    if (_globals(ctx).black_list.contains(_attr(ctx)))
        _pass(ctx) = false;
}

_locals()

_locals() 返回当前正在解析的规则的局部值（如果存在）的引用。如果有两个或更多个局部值，_locals() 返回一个 boost::parser::tuple 的引用。具有局部变量的规则是我们尚未涉及的内容（请参阅“更多关于规则”），但目前您只需要知道您可以为 rule 提供模板参数（LocalState），并且规则将默认构造该类型的一个对象供规则内部使用。您可以通过 _locals() 访问它。

[](auto & ctx) {
    auto & local = _locals(ctx);
    // Use local here.  If 'local' is a hana::tuple, access its members like this:
    using namespace hana::literals;
    auto & first_element = local[0_c];
    auto & second_element = local[1_c];
}

如果没有当前规则，或者当前规则没有局部变量，则返回 none。

_params()

_params()，与 _locals() 一样，适用于当前用于解析的规则（如果存在）（请参阅“更多关于规则”）。如果当前规则只有一个参数，它将返回该参数的引用；如果当前规则有多个参数，它将返回多个值的 boost::parser::tuple 的引用。如果没有当前规则，或者当前规则没有参数，则返回 none。

与 _locals() 不同，您 不 为 rule 提供模板参数。而是调用 rule 的 with() 成员函数（再次参阅“更多关于规则”）。

_no_case()

_no_case() 如果当前解析上下文位于一个或多个（可能嵌套的）no_case[] 指令内部，则返回 true。我没有使用场景，但如果我不公开它，它将是上下文中唯一一个您无法从语义动作内部检查的内容。添加它很容易，所以我添加了。

这个例子与我们到目前为止看到的其他例子非常相似。它之所以不同，仅仅是因为它使用了一个 rule。作为类比，您可以将 char_ 或 double_ 这样的解析器想象成一行代码，而 rule 就像一个函数。像函数一样，rule 有自己的名称，甚至可以前向声明。下面是我们如何定义一个 rule，这类似于前向声明一个函数：

bp::rule<struct doubles, std::vector<double>> doubles = "doubles";

这声明了规则本身。 rule 是一个解析器，我们可以立即在其他解析器中使用它。该定义相当密集；请注意以下几点：

好的，既然 doubles 是一个解析器，它做什么呢？我们通过定义一个现在应该看起来很熟悉的单独的解析器来定义规则的行为：

auto const doubles_def = bp::double_ % ',';

这类似于为前向声明的函数编写定义。请注意，我们使用了名称 doubles_def。现在，doubles 规则解析器和 doubles_def 非规则解析器之间没有联系。这是故意的——我们希望能够单独定义它们。为了将它们连接起来，我们声明了 Boost.Parser 能够理解的接口的函数，并使用标签类型 struct doubles 来将它们连接在一起。我们为此使用了一个宏：

BOOST_PARSER_DEFINE_RULES(doubles);

此宏展开为使规则 doubles 和其解析器 doubles_def 协同工作的必要代码。 _def 后缀是此宏依赖于其工作的命名约定。标签类型允许规则解析器 doubles 在用作解析器时调用这些重载之一。

BOOST_PARSER_DEFINE_RULES 展开为两个名为 parse_rule() 的函数重载。在上面的例子中，每个重载都接受一个 struct doubles 参数（以区分它们与其他规则的 parse_rule() 重载）并使用 doubles_def 进行解析。您永远不需要自己调用 parse_rule() 的任何重载；它由实现 rules 的解析器 rule_parser 内部使用。

下面是为每个规则展开的宏的定义：

#define BOOST_PARSER_DEFINE_IMPL(_, rule_name_)                                \
    template<                                                                  \
        typename Iter,                                                         \
        typename Sentinel,                                                     \
        typename Context,                                                      \
        typename SkipParser>                                                   \
    decltype(rule_name_)::parser_type::attr_type parse_rule(                   \
        decltype(rule_name_)::parser_type::tag_type *,                         \
        Iter & first,                                                          \
        Sentinel last,                                                         \
        Context const & context,                                               \
        SkipParser const & skip,                                               \
        boost::parser::detail::flags flags,                                    \
        bool & success,                                                        \
        bool & dont_assign)                                                    \
    {                                                                          \
        auto const & parser = BOOST_PARSER_PP_CAT(rule_name_, _def);           \
        using attr_t =                                                         \
            decltype(parser(first, last, context, skip, flags, success));      \
        using attr_type = decltype(rule_name_)::parser_type::attr_type;        \
        if constexpr (boost::parser::detail::is_nope_v<attr_t>) {              \
            dont_assign = true;                                                \
            parser(first, last, context, skip, flags, success);                \
            return {};                                                         \
        } else if constexpr (std::is_same_v<attr_type, attr_t>) {              \
            return parser(first, last, context, skip, flags, success);         \
        } else if constexpr (std::is_constructible_v<attr_type, attr_t>) {     \
            return attr_type(                                                  \
                parser(first, last, context, skip, flags, success));           \
        } else {                                                               \
            attr_type attr{};                                                  \
            parser(first, last, context, skip, flags, success, attr);          \
            return attr;                                                       \
        }                                                                      \
    }                                                                          \
                                                                               \
    template<                                                                  \
        typename Iter,                                                         \
        typename Sentinel,                                                     \
        typename Context,                                                      \
        typename SkipParser,                                                   \
        typename Attribute>                                                    \
    void parse_rule(                                                           \
        decltype(rule_name_)::parser_type::tag_type *,                         \
        Iter & first,                                                          \
        Sentinel last,                                                         \
        Context const & context,                                               \
        SkipParser const & skip,                                               \
        boost::parser::detail::flags flags,                                    \
        bool & success,                                                        \
        bool & /*dont_assign*/,                                                \
        Attribute & retval)                                                    \
    {                                                                          \
        auto const & parser = BOOST_PARSER_PP_CAT(rule_name_, _def);           \
        using attr_t =                                                         \
            decltype(parser(first, last, context, skip, flags, success));      \
        if constexpr (boost::parser::detail::is_nope_v<attr_t>) {              \
            parser(first, last, context, skip, flags, success);                \
        } else {                                                               \
            parser(first, last, context, skip, flags, success, retval);        \
        }                                                                      \
    }

现在我们有了 doubles 解析器，我们可以像使用任何其他解析器一样使用它：

auto const result = bp::parse(input, doubles, bp::ws);

完整的程序：

#include <boost/parser/parser.hpp>

#include <deque>
#include <iostream>
#include <string>


namespace bp = boost::parser;


bp::rule<struct doubles, std::vector<double>> doubles = "doubles";
auto const doubles_def = bp::double_ % ',';
BOOST_PARSER_DEFINE_RULES(doubles);

int main()
{
    std::cout << "Please enter a list of doubles, separated by commas. ";
    std::string input;
    std::getline(std::cin, input);

    auto const result = bp::parse(input, doubles, bp::ws);

    if (result) {
        std::cout << "You entered:\n";
        for (double x : *result) {
            std::cout << x << "\n";
        }
    } else {
        std::cout << "Parse failure.\n";
    }
}

这一切都是为了引入 rules 的概念。您可能仍然不太清楚为什么您要使用 rules。 rules 的用例和大量细节在后面的章节“更多关于规则”中。

到目前为止，我们只看到了简单的解析器，它们会重复解析相同的值（无论是否带有逗号和空格）。解析一系列值也很常见。假设您想解析一个员工记录。这是一个您可能会编写的解析器：

namespace bp = boost::parser;
auto employee_parser = bp::lit("employee")
    >> '{'
    >> bp::int_ >> ','
    >> quoted_string >> ','
    >> quoted_string >> ','
    >> bp::double_
    >> '}';

employee_parser 的属性类型是 boost::parser::tuple<int, std::string, std::string, double>。这很好，因为您在无需编写任何语义动作的情况下就获得了记录的所有解析数据。但现在您必须通过索引使用 get() 来获取所有单独的元素，这不太好。直接解析到您的程序将使用的最终数据结构会更好。这通常是某种 struct 或 class。Boost.Parser 支持解析到任意聚合 struct，以及从给定元组可构造的非聚合。

聚合类型作为属性

如果我们有一个 struct，其数据成员的类型与 employee_parser 的 boost::parser::tuple 属性类型中列出的类型相同，那么直接解析到它而不是先解析到元组然后再构造我们的 struct 会更好。幸运的是，这在 Boost.Parser 中直接可用。下面是一个直接解析到兼容的聚合类型的示例。

#include <boost/parser/parser.hpp>

#include <iostream>
#include <string>


struct employee
{
    int age;
    std::string surname;
    std::string forename;
    double salary;
};

namespace bp = boost::parser;

int main()
{
    std::cout << "Enter employee record. ";
    std::string input;
    std::getline(std::cin, input);

    auto quoted_string = bp::lexeme['"' >> +(bp::char_ - '"') >> '"'];
    auto employee_p = bp::lit("employee")
        >> '{'
        >> bp::int_ >> ','
        >> quoted_string >> ','
        >> quoted_string >> ','
        >> bp::double_
        >> '}';

    employee record;
    auto const result = bp::parse(input, employee_p, bp::ws, record);

    if (result) {
        std::cout << "You entered:\nage:      " << record.age
                  << "\nsurname:  " << record.surname
                  << "\nforename: " << record.forename
                  << "\nsalary  : " << record.salary << "\n";
    } else {
        std::cout << "Parse failure.\n";
    }
}

不幸的是，这利用了宽松的属性赋值逻辑； employee_parser 解析器仍然有一个 boost::parser::tuple 属性。有关属性输出参数兼容性的说明，请参阅“The parse() API”。

因此，更常见的是希望创建一个返回特定类型（如 employee）的规则。仅仅通过给规则一个 struct 类型，我们就确保了这个解析器始终生成一个 employee 结构作为其属性，无论它在解析中的哪个位置。如果我们创建一个简单的解析器 P，它使用 employee_p 规则，例如 bp::int >> employee_p，那么 P 的属性类型将是 boost::parser::tuple<int, employee>。

#include <boost/parser/parser.hpp>

#include <iostream>
#include <string>


struct employee
{
    int age;
    std::string surname;
    std::string forename;
    double salary;
};

namespace bp = boost::parser;

bp::rule<struct quoted_string, std::string> quoted_string = "quoted name";
bp::rule<struct employee_p, employee> employee_p = "employee";

auto quoted_string_def = bp::lexeme['"' >> +(bp::char_ - '"') >> '"'];
auto employee_p_def = bp::lit("employee")
    >> '{'
    >> bp::int_ >> ','
    >> quoted_string >> ','
    >> quoted_string >> ','
    >> bp::double_
    >> '}';

BOOST_PARSER_DEFINE_RULES(quoted_string, employee_p);

int main()
{
    std::cout << "Enter employee record. ";
    std::string input;
    std::getline(std::cin, input);

    static_assert(std::is_aggregate_v<std::decay_t<employee &>>);

    auto const result = bp::parse(input, employee_p, bp::ws);

    if (result) {
        std::cout << "You entered:\nage:      " << result->age
                  << "\nsurname:  " << result->surname
                  << "\nforename: " << result->forename
                  << "\nsalary  : " << result->salary << "\n";
    } else {
        std::cout << "Parse failure.\n";
    }
}

就像您可以将一个 struct 作为输出参数传递给 parse()（当解析器的属性类型是元组时）一样，您也可以将一个元组作为输出参数传递给 parse()（当解析器的属性类型是结构体时）。

// Using the employee_p rule from above, with attribute type employee...
boost::parser::tuple<int, std::string, std::string, double> tup;
auto const result = bp::parse(input, employee_p, bp::ws, tup); // Ok!

通用 class 类型作为属性

很多时候，您没有一个想要从中生成的聚合结构。如果 Boost.Parser 能够检测到作为属性生成的元组的成员可以作为某个类型的构造函数的参数，那会比上面的聚合代码更好。所以，Boost.Parser 做到了这一点。

#include <boost/parser/parser.hpp>

#include <iostream>
#include <string>


namespace bp = boost::parser;

int main()
{
    std::cout << "Enter a string followed by two unsigned integers. ";
    std::string input;
    std::getline(std::cin, input);

    constexpr auto string_uint_uint =
        bp::lexeme[+(bp::char_ - ' ')] >> bp::uint_ >> bp::uint_;
    std::string string_from_parse;
    if (parse(input, string_uint_uint, bp::ws, string_from_parse))
        std::cout << "That yields this string: " << string_from_parse << "\n";
    else
        std::cout << "Parse failure.\n";

    std::cout << "Enter an unsigned integer followed by a string. ";
    std::getline(std::cin, input);
    std::cout << input << "\n";

    constexpr auto uint_string = bp::uint_ >> +bp::char_;
    std::vector<std::string> vector_from_parse;
    if (parse(input, uint_string, bp::ws, vector_from_parse)) {
        std::cout << "That yields this vector of strings:\n";
        for (auto && str : vector_from_parse) {
            std::cout << "  '" << str << "'\n";
        }
    } else {
        std::cout << "Parse failure.\n";
    }
}

让我们看看第一个解析。

constexpr auto string_uint_uint =
    bp::lexeme[+(bp::char_ - ' ')] >> bp::uint_ >> bp::uint_;
std::string string_from_parse;
if (parse(input, string_uint_uint, bp::ws, string_from_parse))
    std::cout << "That yields this string: " << string_from_parse << "\n";
else
    std::cout << "Parse failure.\n";

在这里，我们使用解析器 string_uint_uint，它产生一个 boost::parser::tuple<std::string, unsigned int, unsigned int> 属性。当我们尝试将其解析到输出参数 std::string 属性时，它就能正常工作。这是因为 std::string 有一个构造函数，它接受一个 std::string、一个偏移量和一个长度。这是另一个解析：

constexpr auto uint_string = bp::uint_ >> +bp::char_;
std::vector<std::string> vector_from_parse;
if (parse(input, uint_string, bp::ws, vector_from_parse)) {
    std::cout << "That yields this vector of strings:\n";
    for (auto && str : vector_from_parse) {
        std::cout << "  '" << str << "'\n";
    }
} else {
    std::cout << "Parse failure.\n";
}

现在我们有了解析器 uint_string，它产生 boost::parser::tuple<unsigned int, std::string> 属性——末尾的两个 char 组合成一个 std::string。这两个值可以通过计数，使用 T 构造函数来构建一个 std::vector<std::string>。

就像在大多数地方使用聚合体代替元组一样，非聚合 class 类型也可以被替换为元组。这包括将非聚合 class 类型用作 rule 的属性类型。

但是，虽然兼容的元组可以被替换为聚合体，但你不能仅仅因为元组可以用来构造 T，就将一个元组替换为某个 class 类型 T。想想在上面第二个解析尝试中反转替换。将 std::vector<std::string> 转换为 boost::parser::tuple<unsigned int, std::string> 是没有意义的。

通常，你需要解析可能具有多种形式的内容。 operator| 被重载以形成备用解析器。例如

namespace bp = boost::parser;
auto const parser_1 = bp::int_ | bp::eps;

parser_1 匹配一个整数，或者如果失败，则匹配 epsilon，即空字符串。这等同于编写

namespace bp = boost::parser;
auto const parser_2 = -bp::int_;

然而，parser_1 和 parser_2 都不等同于编写这个

namespace bp = boost::parser;
auto const parser_3 = bp::eps | bp::int_; // Does not do what you think.

原因是备用解析器会逐个尝试其子解析器，并停止在第一个匹配的解析器上。 Epsilon 匹配任何内容，因为它长度为零且不消耗任何输入。它甚至匹配输入的末尾。这意味着 parser_3 本身就等同于 eps。

解析带引号的字符串非常常见。然而，当使用跳过符时（你应该 99% 的时间都使用跳过符），带引号的字符串会有点棘手。你不想在字符串中间允许任意的空格，你也不想从字符串中移除所有空格。典型的跳过符 ws 会导致这两种情况都发生。

所以，大多数人会这样编写带引号的字符串解析器

namespace bp = boost::parser;
const auto string = bp::lexeme['"' >> *(bp::char_ - '"') > '"'];

需要注意的一些事项

这是一个非常常见的模式。我已经写了数十次这样的带引号字符串解析器。上面的解析器是快速粗糙的版本。一个更健壮的版本将能够处理字符串中转义的引号，然后也会立即需要支持转义的转义字符。

Boost.Parser 提供了 quoted_string 来代替这个非常常见的模式。它支持引号和转义字符，使用反斜杠作为转义字符。

namespace bp = boost::parser;

auto result1 = bp::parse("\"some text\"", bp::quoted_string, bp::ws);
assert(result1);
std::cout << *result1 << "\n"; // Prints: some text

auto result2 = bp::parse(R"("some \"text\"")", bp::quoted_string, bp::ws);
assert(result2);
std::cout << *result2 << "\n"; // Prints: some "text"

尽管这个用例非常普遍，但仍有许多非常相似但它无法覆盖的用例。因此，quoted_string 有一些选项。如果你用一个字符调用它，它会返回一个 quoted_string，它将该字符用作引号字符。

auto result3 = bp::parse("!some text!", bp::quoted_string('!'), bp::ws);
assert(result3);
std::cout << *result3 << "\n"; // Prints: some text

你也可以提供一个字符范围。范围中的一个字符必须引用字符串的两端；不允许不匹配。想想 Python 如何允许你用 '"' 或 '\'' 来引用字符串，但两边必须使用相同的字符。

auto result4 = bp::parse("'some text'", bp::quoted_string("'\""), bp::ws);
assert(result4);
std::cout << *result4 << "\n"; // Prints: some text

在带引号的字符串解析器中做的另一件常见的事情是识别转义序列。如果你有不需要任何实际解析的简单转义序列，比如 C++ 的简单转义序列，你也可以提供一个 symbols 对象。 symbols<T> 的模板参数 T 必须是 char 或 char32_t。你不需要包含转义的反斜杠或转义的引号字符，因为它们总是有效的。

// the c++ simple escapes
bp::symbols<char> const escapes = {
    {"'", '\''},
    {"?", '\?'},
    {"a", '\a'},
    {"b", '\b'},
    {"f", '\f'},
    {"n", '\n'},
    {"r", '\r'},
    {"t", '\t'},
    {"v", '\v'}};
auto result5 =
    bp::parse("\"some text\r\"", bp::quoted_string('"', escapes), bp::ws);
assert(result5);
std::cout << *result5 << "\n"; // Prints (with a CRLF newline): some text

此外，对于上面显示的每种形式，你可以选择性地提供一个解析器作为最后一个参数，它将用于解析引号内的每个字符。你必须提供一个实际的完整解析器；你不能提供一个字符或字符串字面量。如果你不提供字符解析器，则使用 char_。

auto result6 = bp::parse(
    "'some text'", bp::quoted_string("'\"", bp::char_('g')), bp::ws);
assert(!result6);
result6 =
    bp::parse("'gggg'", bp::quoted_string("'\"", bp::char_('g')), bp::ws);
assert(result6);
std::cout << *result6 << "\n"; // Prints: gggg

现在你已经看了一些例子，让我们更详细地看看解析是如何工作的。考虑这个例子。

namespace bp = boost::parser;
auto int_pair = bp::int_ >> bp::int_;         // Attribute: tuple<int, int>
auto int_pairs_plus = +int_pair >> bp::int_;  // Attribute: tuple<std::vector<tuple<int, int>>, int>

int_pairs_plus 必须匹配一个或多个 int 对（使用 int_pair），然后必须匹配一个额外的 int。换句话说，它匹配输入中的任何奇数（大于 1）个 int。我们来看看这个解析是如何进行的。

auto result = bp::parse("1 2 3", int_pairs_plus, bp::ws);

在解析开始时，顶层解析器使用其第一个子解析器（如果有）开始解析。因此，int_pairs_plus 是一个序列解析器，它会将控制权传递给它的第一个解析器 +int_pair。然后 +int_pair 将使用 int_pair 来进行解析，而 int_pair 又会使用 bp::int_。这创建了一个解析器堆栈，每个解析器使用一个特定的子解析器。

步骤 1) 输入是 "1 2 3"，活动解析器堆栈是 int_pairs_plus -> +int_pair -> int_pair -> bp::int_。（将“->”读作“使用”。）这解析了 "1"，并且之后的空格被 bp::ws 跳过。控制权传递给 int_pair 中的第二个 bp::int_ 解析器。

步骤 2) 输入是 "2 3"，解析器堆栈看起来相同，只是活动解析器是 int_pair 中的第二个 bp::int_。该解析器消耗 "2"，然后 bp::ws 跳过后面的空格。由于我们已经完成了 int_pair 的匹配，它的 boost::parser::tuple<int, int> 属性已完成。它的父级是 +int_pair，因此该元组属性被推送到 +int_pair 的属性后面，该属性是一个 std::vector<boost::parser::tuple<int, int>>。控制权传递到 int_pair 的父级 +int_pair。由于 +int_pair 是一个一次或多次解析器，它开始一个新的迭代；控制权再次传递给 int_pair。

步骤 3) 输入再次是 "3"，解析器堆栈看起来相同，只是活动解析器是 int_pair 中的第一个 bp::int_，并且我们处于 +int_pair 的第二次迭代中。该解析器消耗 "3"。由于这是输入的末尾，int_pair 的第二个 bp::int_ 没有匹配。这个部分的匹配 "3" 不应被计算，因为它不是完整匹配的一部分。因此，int_pair 指示其失败，并且 +int_pair 停止迭代。由于它确实匹配了一次，+int_pair 不会失败；它是一个零次或多次解析器；其子解析器在第一次成功后的失败不会导致其失败。控制权传递给 int_pairs_plus 中的下一个序列解析器。

步骤 4) 输入再次是 "3"，解析器堆栈是 int_pairs_plus -> bp::int_。这解析了 "3"，并且解析到达了输入末尾。控制权传递给 int_pairs_plus，它刚刚成功匹配了其序列中的所有解析器。然后它生成它的属性，一个 boost::parser::tuple<std::vector<boost::parser::tuple<int, int>>, int>，它被从 bp::parse() 返回。

关于步骤 #3 和 #4 之间需要注意的一点：在 #4 开始时，输入位置已经回退到 #3 开始时的位置。这种回溯发生在备用解析器中，当一个备用解析器失败时。在 P 解析过程中消耗的输入部分基本上被“归还”。

解析器详解

到目前为止，解析器被呈现为某种抽象实体。你可能想要更多细节。一个 Boost.Parser 解析器 P 是一个可调用的对象，它具有一对函数调用运算符重载。这两个函数非常相似，并且在许多解析器中，一个函数是基于另一个函数实现的。第一个函数进行解析并返回解析器的默认属性。第二个函数执行完全相同的解析，但接受一个输出参数，它将解析器的属性写入其中。输出参数不需要与默认属性相同，但它们需要兼容。

兼容性意味着默认属性在某种程度上可以赋值给输出参数。这通常意味着直接赋值，但也可能意味着元组 -> 聚合体或聚合体 -> 元组的转换。对于序列类型，兼容性意味着序列类型具有 insert 或 push_back 及其通常的语义。这意味着解析器 +boost::parser::int_ 可以像 std::vector<int> 一样填充 std::set<int>。

一些解析器还有执行匹配所需的附加状态。例如，char_ 解析器可以被参数化为一个要匹配的单个代码点；该代码点的确切值存储在解析器对象中。

没有解析器直接支持解析器上定义的所有操作（operator|、operator>> 等）。相反，有一个名为 parser_interface 的模板，它支持所有这些操作。 parser_interface 包装每个解析器，将其存储为数据成员，并将其改编为通用使用。你只应该在调试器中看到 parser_interface，或者可能在一些参考文档中。你不应该在自己的代码中编写它。

如前一页所述，当解析尝试匹配当前解析器 P，匹配了部分输入，但未能完全匹配 P 时，就会发生回溯。 P 解析过程中消耗的输入部分基本上被“归还”。

这是必需的，因为 P 可能由子解析器组成，每个成功的子解析器都会尝试消耗输入、生成属性等。当后面的子解析器失败时，P 的解析就会失败，并且输入必须被回退到 P 开始解析时的位置，而不是最新的匹配子解析器停止的位置。

备用解析器通常会逐个评估多个子解析器，向前移动然后恢复输入位置，直到其中一个子解析器成功。考虑这个例子。

namespace bp = boost::parser;
auto const parser = repeat(53)[other_parser] | repeat(10)[other_parser];

评估 parser 意味着尝试匹配 other_parser 53 次，如果失败，则尝试匹配 other_parser 10 次。假设你解析匹配 other_parser 11 次的输入。 parser 将匹配它。在解析过程中，它还将评估 other_parser 21 次。

repeat(53)[other_parser] 和 repeat(10)[other_parser] 的属性分别是 std::vector<ATTR(other_parser)；假设 ATTR(other_parser) 是 int。整个 parser 的属性也是如此，std::vector<int>。由于 other_parser 正在忙于生成 int —— 确切地说是 21 个 —— 你可能会想，当 repeat(53)[other_parser] 无法找到所有 53 个输入时，在 repeat(53)[other_parser] 评估过程中生成的 int 会发生什么。届时，它的 std::vector<int> 将包含 11 个 int。

当 repeat-parser 失败并生成属性时，它会清除其容器。这适用于上面的解析器，但也适用于所有其他 repeat 解析器，包括使用 operator+ 或 operator* 创建的解析器。

因此，在 parser 成功解析 10 个输入后（因为备用方案的右侧只消耗 10 次重复），parser 的 std::vector<int> 属性将包含 10 个 int。

期望点

好了，那么如果解析器都尽力匹配输入，并且都是全有或全无的，这是否就为忽略各种错误输入留下了空间？考虑 解析 JSON 示例中的顶层解析器。

auto const value_p_def =
    number | bp::bool_ | null | string | array_p | object_p;

如果我用它来解析 "\"" 会怎样？解析尝试 number，失败。然后它尝试 bp::bool_，失败。然后 null 也失败。最后，它开始解析 string。好消息是，第一个字符是 JSON 字符串的开引号。不幸的是，这也是输入的末尾，所以 string 也必须失败。但是，我们可能不想在解析 string 现在就放弃，然后尝试 array_p，对吧？如果用户写了一个开引号但没有匹配的闭引号，那么它不是 value_p_def 的某个备用方案的前缀；它是格式错误的 JSON。这是 string 规则的解析器

auto const string_def = bp::lexeme['"' >> *(string_char - '"') > '"'];

注意，在右侧使用了 operator> 而不是 operator>>。这表示与 operator>> 相同的序列操作，不同的是它还表示一个期望。如果 operator> 前的解析成功，那么它后面的任何内容必须也成功。否则，顶层解析失败，并发出诊断信息。它会显示类似“这里期望 ‘"’。”的消息，引用该行，并用插入符号指向输入中期望右侧匹配的位置。

选择使用 > 而不是 >> 是你指示 Boost.Parser 解析失败是硬错误还是非硬错误的方式，分别是。

在编写解析器时，经常会遇到这样一种情况：有一组字符串，当解析它们时，它们与一组值一对一地关联。当需要将每个字符串与属性通过语义动作关联起来时，编写识别所有可能输入字符串的解析器会很繁琐。相反，我们可以使用符号表。

假设我们要解析罗马数字，这是最常见的与工作相关的解析问题之一。我们想识别以任意数量的“M”开头的数字，代表千位，后面跟着百位、十位和个位。其中任何一个都可能在输入中缺失，但并非全部。这里有三个符号 Boost.Parser 表，我们可以用它们分别识别个位、十位和百位值

bp::symbols<int> const ones = {
    {"I", 1},
    {"II", 2},
    {"III", 3},
    {"IV", 4},
    {"V", 5},
    {"VI", 6},
    {"VII", 7},
    {"VIII", 8},
    {"IX", 9}};

bp::symbols<int> const tens = {
    {"X", 10},
    {"XX", 20},
    {"XXX", 30},
    {"XL", 40},
    {"L", 50},
    {"LX", 60},
    {"LXX", 70},
    {"LXXX", 80},
    {"XC", 90}};

bp::symbols<int> const hundreds = {
    {"C", 100},
    {"CC", 200},
    {"CCC", 300},
    {"CD", 400},
    {"D", 500},
    {"DC", 600},
    {"DCC", 700},
    {"DCCC", 800},
    {"CM", 900}};

symbols 将 char 的字符串映射到其关联的属性。属性的类型必须指定为 symbols 的模板参数——在这种情况下是 int。

遇到的任何“M”都应向结果添加 1000，所有其他值都来自符号表。这是我们需要做的语义动作

int result = 0;
auto const add_1000 = [&result](auto & ctx) { result += 1000; };
auto const add = [&result](auto & ctx) { result += _attr(ctx); };

add_1000 只是向 result 添加 1000。 add 将其解析器产生的任何属性添加到 result。

现在我们只需要将这些片段组合起来创建一个解析器

using namespace bp::literals;
auto const parser =
    *'M'_l[add_1000] >> -hundreds[add] >> -tens[add] >> -ones[add];

这里我们引入了一些新东西，所以我们来分解一下。 'M'_l 是一个 字面量解析器。也就是说，它是一个解析字面量 char、代码点或字符串的解析器。在这种情况下，正在解析 char 'M'。末尾的 _l 部分是一个 UDL 后缀，你可以将其放在任何 char、char32_t 或 char const * 之后来形成字面量解析器。你也可以通过编写 lit()，传递上面提到的类型之一作为参数，来创建一个字面量解析器。

考虑到我们在之前的例子中使用了字面量 ','，为什么我们需要这个？原因在于 'M' 没有在与另一个 Boost.Parser 解析器一起的表达式中使用。它被用在 *'M'_l[add_1000] 中。如果我们写了 *'M'[add_1000]，那显然是错误的；char 没有与之关联的 operator*，也没有 operator[]。

接下来是 -hundreds[add]。到目前为止，索引运算符的使用应该非常熟悉了；它将语义动作 add 与解析器 hundreds 关联起来。前面的 operator- 是新的。它的意思是它所应用的解析器是可选的。你可以将其读作“零个或一个”。因此，如果 hundreds 在 *'M'[add_1000] 之后没有被成功解析，什么都不会发生，因为 hundreds 是允许缺失的——它是可选的。如果 hundreds 被成功解析，比如匹配了 "CC"，则在 add 内，产生的属性 200 会被添加到 result 中。

这是程序的完整列表。注意，在这里使用空格跳过符是不合适的，因为整个解析是一个单独的数字，所以它被删除了。

#include <boost/parser/parser.hpp>

#include <iostream>
#include <string>


namespace bp = boost::parser;

int main()
{
    std::cout << "Enter a number using Roman numerals. ";
    std::string input;
    std::getline(std::cin, input);

    bp::symbols<int> const ones = {
        {"I", 1},
        {"II", 2},
        {"III", 3},
        {"IV", 4},
        {"V", 5},
        {"VI", 6},
        {"VII", 7},
        {"VIII", 8},
        {"IX", 9}};

    bp::symbols<int> const tens = {
        {"X", 10},
        {"XX", 20},
        {"XXX", 30},
        {"XL", 40},
        {"L", 50},
        {"LX", 60},
        {"LXX", 70},
        {"LXXX", 80},
        {"XC", 90}};

    bp::symbols<int> const hundreds = {
        {"C", 100},
        {"CC", 200},
        {"CCC", 300},
        {"CD", 400},
        {"D", 500},
        {"DC", 600},
        {"DCC", 700},
        {"DCCC", 800},
        {"CM", 900}};

    int result = 0;
    auto const add_1000 = [&result](auto & ctx) { result += 1000; };
    auto const add = [&result](auto & ctx) { result += _attr(ctx); };

    using namespace bp::literals;
    auto const parser =
        *'M'_l[add_1000] >> -hundreds[add] >> -tens[add] >> -ones[add];

    if (bp::parse(input, parser) && result != 0)
        std::cout << "That's " << result << " in Arabic numerals.\n";
    else
        std::cout << "That's not a Roman number.\n";
}

诊断消息

就像 rule 一样，你可以给 symbols 提供一段诊断文本，当解析在期望点失败时，Boost.Parser 生成的错误消息将使用这段文本，如 错误处理和调试 中所述。有关详细信息，请参阅 symbols 构造函数。

前面的例子展示了如何使用符号表作为固定的查找表。如果我们想在解析过程中向表中添加内容怎么办？我们可以这样做，但必须在语义动作内部进行。首先，这是我们的符号表，已经包含了一个值

bp::symbols<int> const symbols = {{"c", 8}};
assert(parse("c", symbols));

不出所料，使用符号表作为解析器来解析符号表中的一个字符串是有效的。现在，这是我们的解析器

auto const parser = (bp::char_ >> bp::int_)[add_symbol] >> symbols;

在这里，我们将语义动作附加到了序列解析器 (bp::char_ >> bp::int_)，而不是一个简单的解析器，如 double_。这个序列解析器包含两个解析器，每个都有自己的属性，因此它产生两个属性作为元组。

auto const add_symbol = [&symbols](auto & ctx) {
    using namespace bp::literals;
    // symbols::insert() requires a string, not a single character.
    char chars[2] = {_attr(ctx)[0_c], 0};
    symbols.insert(ctx, chars, _attr(ctx)[1_c]);
};

在语义动作内部，我们可以使用 Boost.Hana 提供的 UDLs 和 boost::hana::tuple::operator[]() 来获取属性元组的第一个元素。第一个属性，来自 char_，是 _attr(ctx)[0_c]，第二个属性，来自 int_，是 _attr(ctx)[1_c]（如果 boost::parser::tuple 是 std::tuple 的别名，你将使用 std::get 或 boost::parser::get 来代替）。要将符号添加到符号表，我们调用 insert()。

auto const parser = (bp::char_ >> bp::int_)[add_symbol] >> symbols;

在解析过程中，("X", 9) 被解析并添加到符号表中。然后，第二个 'X' 被符号表解析器识别。但是

assert(!parse("X", symbols));

如果我们再次解析，我们会发现 "X" 没有保留在符号表中。 symbols 被声明为 const 这一事实可能已经暗示了这一点。

完整的程序：

#include <boost/parser/parser.hpp>

#include <iostream>
#include <string>


namespace bp = boost::parser;

int main()
{
    bp::symbols<int> const symbols = {{"c", 8}};
    assert(parse("c", symbols));

    auto const add_symbol = [&symbols](auto & ctx) {
        using namespace bp::literals;
        // symbols::insert() requires a string, not a single character.
        char chars[2] = {_attr(ctx)[0_c], 0};
        symbols.insert(ctx, chars, _attr(ctx)[1_c]);
    };
    auto const parser = (bp::char_ >> bp::int_)[add_symbol] >> symbols;

    auto const result = parse("X 9 X", parser, bp::ws);
    assert(result && *result == 9);
    (void)result;

    assert(!parse("X", symbols));
}

可以将符号永久添加到 symbols 中。要做到这一点，你必须使用一个可变的 symbols 对象 s，并通过调用 s.insert_for_next_parse() 来添加符号，而不是 s.insert()。这两个操作是正交的，所以如果你想将一个符号添加到当前顶级解析的表中，并将其保留在表中以供后续的顶级解析使用，你需要同时调用这两个函数。

还可以从符号表中擦除单个条目，或完全清除符号表。与插入一样，有适用于当前解析的擦除和清除版本，以及另一个仅适用于后续解析的版本。完整的操作集可以在 symbols API 文档中找到。

Boost.Parser 附带了所有解析器，能够满足大多数解析任务的需求。每个解析器都是一个 constexpr 对象，或者是一个 constexpr 函数。一些非函数对象也是可调用的，例如 char_，它可以直接使用，或带参数使用，例如 char_('a', 'z')。任何可调用的解析器，无论是函数还是可调用对象，从现在起都称为 可调用解析器。请注意，没有空参数的可调用解析器；它们都接受一个或多个参数。

每个可调用解析器都接受一个或多个 解析参数。解析参数可以是值，也可以是接受解析上下文引用的可调用对象。引用参数可以是可变的或常量的。例如

struct get_attribute
{
    template<typename Context>
    auto operator()(Context & ctx)
    {
        return _attr(ctx);
    }
};

这也可以是 lambda。例如

[](auto const & ctx) { return _attr(ctx); }

从解析参数（可以是值或接受解析上下文参数的可调用对象）生成值的操作，称为 解析 该解析参数。如果解析参数 arg 可以用当前上下文调用，那么 arg 的解析值是 arg(ctx)；否则，解析值就是 arg。

一些可调用解析器接受一个 解析谓词。解析谓词与解析参数不完全相同，因为它必须是可调用对象，而不能是值。解析谓词的返回类型必须可以上下文转换为 bool。例如

struct equals_three
{
    template<typename Context>
    bool operator()(Context const & ctx)
    {
        return _attr(ctx) == 3;
    }
};

这当然也可以是 lambda

[](auto & ctx) { return _attr(ctx) == 3; }

概念上的宏 RESOLVE() 扩展为解析参数或解析谓词的解析结果。你会在其余文档中看到它。

解析参数使用方式的示例

namespace bp = boost::parser;
// This parser matches one code point that is at least 'a', and at most
// the value of last_char, which comes from the globals.
auto last_char = [](auto & ctx) { return _globals(ctx).last_char; }
auto subparser = bp::char_('a', last_char);

暂时不用担心全局变量是什么；关键是你可以通过使用解析上下文，使传递给解析器的任何参数依赖于解析的当前状态。

namespace bp = boost::parser;
// This parser parses two code points.  For the parse to succeed, the
// second one must be >= 'a' and <= the first one.
auto set_last_char = [](auto & ctx) { _globals(ctx).last_char = _attr(x); };
auto parser = bp::char_[set_last_char] >> subparser;

每个可调用解析器都返回一个新的解析器，该解析器使用调用中给定的参数进行参数化。

此表列出了所有 Boost.Parser 解析器。对于可调用解析器，每个参数元数都有一个单独的条目。对于解析器 p，如果 p 没有参数的条目，则 p 是一个函数，它本身不能用作解析器；它必须被调用。在下表中

如果你有一个 Boost.Parser 解析器未覆盖的整数类型 IntType，你可以显式指定基数/进制或数字的位数。你可以通过在正确整数类型的现有解析器上调用 base() 和 digits() 成员函数来实现。所以如果 IntType 是无符号的，你会使用 uint_。如果是带符号的，你会使用 int_。例如

constexpr auto hex_int = bp::uint_.base<16>();

你只需将你想要的约束链接在一起，例如 .base<16>().digits<2>() 或 .digits<4>().base<8>()。

所以，如果你想解析八个十六进制数字连续出现，以识别 C++ 那样的 Unicode 字符字面量（例如 \Udeadbeef），你可以使用这个解析器来处理末尾的数字。

constexpr auto hex_4_def = bp::uint_.base<16>().digits<8>();

如果你想指定一个可接受的数字范围，请使用 .digits<LO, HI>()。 HI 和 LO 都是包含边界。