c++ - 如果操作符 ">>"的右侧失败，如何使规则失败，在 boostspirit qi 中

Question

为了保持简单，假设我需要解析A，然后解析B

我指的不是字母，当然，A 和 B 可以是 (qi::char_) 或 (qi::char_('$') | qi::char_('_') | ascii::alpha)，或其他。

所以:

rule = A >> B;

问题是，如果 B 失败，规则不会失败，我会得到 A。我尝试使用 +B 但结果是相同的。并且:

rule = A > B;

失败时抛出异常。

更新:我编辑了这个问题来解释上述陈述是错误的(正如用户sehe证明的那样)，我相信该规则没有失败，因为当我尝试:

auto A = qi::copy(qi::char_("$") | qi::alpha);
auto B = qi::copy(qi::char_("z"));
auto C = qi::copy(qi::string("$x"));
std::string s1 = "$x";
std::string s2 = "";
qi::parse(s1.begin(), s1.end(), (A >> B) | C, s2);

我会得到 s2="$$x" ，所以我认为 A 没有失败。现在我知道这是一个不同的问题。但规则确实失败了。

Answer 1

问。 问题是，如果 B 失败，规则不会失败，我会得到 A

A.这不是真的，请参阅下面的详细演示

---

问。它后面可能是 E，但我不想得到 CE

A.在下面的测试用例中寻找肯定断言(C >> &E 在这里就可以了)

---

这是因为我正在尝试解析关键字和标识符，所以 int 是关键字，int4 是标识符。因此，关键字是我定义的一个字符串，后面不跟数字或字母。有什么想法吗？

是的，请参阅:

• boost::spirit::qi keywords and identifiers
• distinct在 spirit 库中

Live Coliru

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

namespace qi = boost::spirit::qi;

template <typename Grammar>
bool check(Grammar const& g, std::string const& input, qi::unused_type) {
    auto f = input.begin(), l = input.end();
    try {
        return qi::parse(f, l, g);
    } catch(...) {
        return false;
    }
}

template <typename Grammar, typename Skipper>
bool check(Grammar const& g, std::string const& input, Skipper const& s) {
    auto f = input.begin(), l = input.end();
    try {
        return qi::phrase_parse(f, l, g, s);
    } catch(...) {
        return false;
    }
}

#define REPORT(g, i, s, expect) do { assert(expect == check(g, i, s)); } while(0)
#define SHOULD_WORK(g, i, s) REPORT(g, i, s, true)
#define SHOULD_FAIL(g, i, s) REPORT(g, i, s, false)

template <typename Skipper = qi::unused_type>
void do_all_tests(Skipper const& s = Skipper()) {

    auto A = qi::copy(qi::char_("$_") | qi::alpha);
    auto B = qi::copy(qi::char_("z"));

    // using skipper:
    SHOULD_WORK(A >> B , "$z", s);
    SHOULD_FAIL(A >> B , "$.", s);
    SHOULD_FAIL(A >> B , "$" , s);

    SHOULD_WORK(A  > B , "$z", s);
    SHOULD_FAIL(A  > B , "$.", s);
    SHOULD_FAIL(A  > B , "$" , s);

    // positive assertion (does not consume B)
    SHOULD_WORK(A >> &B, "$z", s);
    SHOULD_FAIL(A >> &B, "$.", s);
    SHOULD_FAIL(A >> &B, "$" , s);

    SHOULD_WORK(A  > &B, "$z", s);
    SHOULD_FAIL(A  > &B, "$.", s);
    SHOULD_FAIL(A  > &B, "$" , s);

    // negative assertion:
    SHOULD_FAIL(A >> !B, "$z", s);
    SHOULD_WORK(A >> !B, "$.", s);
    SHOULD_WORK(A >> !B, "$" , s);

    SHOULD_FAIL(A  > !B, "$z", s);
    SHOULD_WORK(A  > !B, "$.", s);
    SHOULD_WORK(A  > !B, "$" , s);

}

int main() {
    do_all_tests(qi::unused); // no skipper
    do_all_tests(qi::space);
    std::cout << "All tests succeeded\n";
}

打印

All tests succeeded