1

我有一个简单的结构

// in namespace client
struct UnaryExpression
{
    std::string key;
    SomeEnums::CompareType op;
};

SomeEnums::CompareType是一个枚举，我在其中定义了一个符号表：

struct UnaryOps : bsq::symbols<char, SomeEnums::CompareType>
{
    UnaryOps() : bsq::symbols<char, SomeEnums::CompareType>(std::string("UnaryOps"))
    {
        add("exists", SomeEnums::Exists)
          ("nexists", SomeEnums::NotExists);
    }
};

我有两种不同的方式来解析结构，我在另一个线程中询问并开始工作（大部分）。

我的语法如下所示：

template<typename Iterator>
struct test_parser : bsq::grammar<Iterator, client::UnaryExpression(), bsq::ascii::space_type>
{
    test_parser()
        : test_parser::base_type(unaryExp, std::string("Test"))
    {
        using bsq::no_case;

        key %= bsq::lexeme[bsq::alnum >> +(bsq::alnum | bsq::char_('.'))];

        unaryExp %= unaryE | unaryF;
        unaryE %= key >> no_case[unaryOps];
        unaryF %= no_case[unaryOps] >> '(' >> key >> ')';
    };

    UnaryOps unaryOps;

    bsq::rule<Iterator, std::string(), bsq::ascii::space_type> key;
    bsq::rule<Iterator, client::UnaryExpression(), bsq::ascii::space_type> unaryExp;
    bsq::rule<Iterator, client::UnaryExpression(), bsq::ascii::space_type> unaryE;
    bsq::rule<Iterator, client::UnaryFunction(), bsq::ascii::space_type> unaryF;
};

我正在使用以下逻辑解析代码：

bool r = phrase_parse(iter, end, parser, bsq::ascii::space, exp);

if (r && iter == end)
{
    std::cout << "-------------------------\n";
    std::cout << "Parsing succeeded\n";
    std::cout << "key: " << exp.key << "\n";
    std::cout << "op : " << exp.op << "\n";
    std::cout << "-------------------------\n";
}

如果我输入 likefoo exists并且 exp.key 等于“foo”并且 exp.op 等于相应的枚举值（在本例中为 0），这一切都可以正常工作。类似的东西foo1 nexists也有效。

但是，第二条规则并不像我预期的那样起作用。如果我给它输入，nexists(foo)那么我得到以下输出：

-------------------------
Parsing succeeded
key: nexistsfoo
op : 1
-------------------------

似乎枚举值设置得当，但我无法弄清楚为什么“nexsts”会被添加到密钥字符串之前。有人可以告诉我如何修复我的规则，以便密钥与第二条规则相等吗？

我在这里发布了一份精简代码的副本，说明了我的问题：http: //pastebin.com/402M9iTS

4

0 回答 0