在 boost::spirit::qi 中，是否可以在运行时动态修改规则定义

Question

我用 boost::spirit::qi::rule 写了一些语法来解析互联网数据包。语法是这样的：

qi::rule<Iterator> start, request, response, status, query ;
start = (request | response | status | query) >> lit("\r\n");

为了提高性能，用户可能希望在运行时跳过一些规则，例如忽略 "response","status","query" 只尝试匹配请求，所以规则会变成：

start = (request ) >> lit("\r\n"); 

可以这样做吗？例如，是否有像“disable()”这样的函数来禁用规则“响应”、“状态”和“查询”？

Answer 1

最自然的方法是为您的更多限制场合使用不同的解析器。

另外，如果性能如此重要，您甚至不能多做 3 或 4 个字符比较

• 您可能应该使用手写解析器（一般来说，Spirit 的自动属性处理并不总是最佳的）或
• 考虑静态优化扫描（如 Boost Xpressive 或 Spirit Lex）
• 你可能做错了什么（如果你有一个次优的语法，你可能有很多回溯会降低性能 - 就像退化的正则表达式 (https://www.owasp.org/index.php/Regular_expression_Denial_of_Service_-_ReDoS)）

也就是说，这里有一些选项：

1。通过qi::lazy使用可变规则

#include <boost/spirit/include/qi.hpp>

namespace qi    = boost::spirit::qi;
namespace phx   = boost::phoenix;

int main()
{
    typedef std::string::const_iterator It;
    qi::rule<It> 
        request  = "request",
        response = "response",
        status   = "status",
        query    = "query",
        // 
        allowed;

    static qi::rule<It> const start = qi::lazy(phx::ref(allowed)) >> qi::lit("\r\n");
    static const auto test = [](std::string const& input) { return qi::parse(begin(input), end(input), start); };

    for (int i=0; i<10; ++i)
    {
        switch(rand()%3)
        {
            case 0: allowed = request; break;
            case 1: allowed = request | response | query; break;
            case 2: allowed = request | response | status | query; break;
        }

        std::cout << "status: "    << test("status\r\n")   << "\t"
                  << "response: "  << test("response\r\n") << "\t"
                  << "request:  "  << test("request\r\n")  << "\n";
    }
}

就像 Mike 提到的，这也用于 Nabialek 技巧，尽管 qi::lazy 是这里的基本要素。

这个打印，例如：

status: 0   response: 1 request:  1
status: 0   response: 1 request:  1
status: 0   response: 0 request:  1
status: 0   response: 1 request:  1
status: 1   response: 1 request:  1
status: 0   response: 1 request:  1
status: 0   response: 1 request:  1
status: 0   response: 0 request:  1
status: 0   response: 0 request:  1
status: 0   response: 1 request:  1

2。使用带有qi::lazy 的继承属性

与上面非常相似，您可以将“子规则”作为继承属性传递。我不确定我是否会推荐这个，因为我在过去的示例中看到了未定义的行为，请参见例如

• Factoring out common parts of Spirit rules（阅读 cmets！）
• 还有C++ Boost qi recursive rule construction 说明qi::lazy 本身如何不支持继承属性

3。只需使用单独的规则

在我看来这是最自然的：

std::function<bool(string)> test;
switch(rand()%3)
{
    case 0: test = [&](std::string const& input) { return qi::parse(begin(input), end(input), request); }; break;
    case 1: test = [&](std::string const& input) { return qi::parse(begin(input), end(input), request | response | query); }; break;
    case 2: test = [&](std::string const& input) { return qi::parse(begin(input), end(input), request | response | status | query); }; break;
}

查看完整示例：http://coliru.stacked-crooked.com/a/603f093add6b9799

Answer 2

是的，这可以通过使用qi::symbols 解析器来实现。可以在运行时更改使用的符号，因此您可以更改行为。要使用这个解析器来获取完整的规则，有一个小技巧，称为 nabialek 技巧http://boost-spirit.com/home/articles/qi-example/nabialek-trick/。

基本上它展示了如何在符号解析器中挂钩完整的规则。