c++ - 在 Boost.Spirit 中解析短语开头之前的结尾

Question

我正在尝试让 Boost.Spirit 解析 MSVC 损坏的符号。这些采取的形式:


?myvolatileStaticMember@myclass@@2HC
这意味着“volatile int myclass::myvolatileStaticMember”。

解析的“关键”是双符号“@@”。 @@ 之前是符号的名称，它由一个 C++ 标识符和后跟零个或多个“@”的附加标识符组成，以在其绝对命名空间层次结构中完全表示该符号。 @@ 之后是标识符的说明(变量、函数等)

现在，我可以让 Boost.Spirit 解析 @@ 之前的部分或 @@ 之后的部分。我还没有想出如何让 Boost.Spirit 找到 @@ 并将它之前的内容提供给一个自定义解析器，并将它之后的内容提供给另一个自定义解析器。

这是我对 @@ 之前部分的解析器:

// This grammar is for a MSVC mangled identifier
template<typename iterator> struct msvc_name : grammar<iterator, SymbolType(), locals<SymbolType, string>>
{
    SymbolTypeDict &typedict;
    void name_writer(SymbolType &val, const string &i) const { val.name=i; }
    void dependent_writer(SymbolType &val, const string &i) const
    {
        SymbolTypeDict::const_iterator dt=typedict.find(i);
        if(dt==typedict.end())
        {
            auto _dt=typedict.emplace(make_pair(i, SymbolType(SymbolTypeQualifier::None, SymbolTypeType::Namespace, i)));
            dt=_dt.first;
        }
        val.dependents.push_back(&dt->second);
    }
    // These work by spreading the building of a templated type over multiple calls using local variables _a and _b
    // We accumulate template parameters into _a and accumulate mangled symbolness into _b
    void begin_template_dependent_writer(SymbolType &, SymbolType &a, string &b, const string &i) const
    {
        a=SymbolType(SymbolTypeQualifier::None, SymbolTypeType::Class, i);
        b=i;
    }
    void add_template_constant_dependent_writer(SymbolType &a, string &b, long long constant) const
    {
        string i("_c"+to_string(constant));
        SymbolTypeDict::const_iterator dt=typedict.find(i);
        if(dt==typedict.end())
        {
            auto _dt=typedict.emplace(make_pair(i, SymbolType(SymbolTypeQualifier::None, SymbolTypeType::Constant, to_string(constant))));
            dt=_dt.first;
        }
        a.templ_params.push_back(&dt->second);
        b.append(i);
    }
    void add_template_type_dependent_writer(SymbolType &a, string &b, SymbolTypeType type) const
    {
        string i("_t"+to_string(static_cast<int>(type)));
        SymbolTypeDict::const_iterator dt=typedict.find(i);
        if(dt==typedict.end())
        {
            auto _dt=typedict.emplace(make_pair(i, SymbolType(SymbolTypeQualifier::None, type)));
            dt=_dt.first;
        }
        a.templ_params.push_back(&dt->second);
        b.append(i);
    }
    void finish_template_dependent_writer(SymbolType &val, SymbolType &a, string &b) const
    {
        SymbolTypeDict::const_iterator dt=typedict.find(b);
        if(dt==typedict.end())
        {
            auto _dt=typedict.emplace(make_pair(b, a));
            dt=_dt.first;
        }
        val.dependents.push_back(&dt->second);
    }
    msvc_name(SymbolTypeDict &_typedict) : msvc_name::base_type(start), typedict(_typedict)
    {
        identifier=+(char_ - '@');
        identifier.name("identifier");
        template_dependent_identifier=+(char_ - '@');
        template_dependent_identifier.name("template_dependent_identifier");
        dependent_identifier=+(char_ - '@');
        dependent_identifier.name("dependent_identifier");
        start = identifier [ boost::phoenix::bind(&msvc_name::name_writer, this, _val, _1) ] >> *(
            lit("@@") >> eps
            | (("@?$" > template_dependent_identifier [ boost::phoenix::bind(&msvc_name::begin_template_dependent_writer, this, _val, _a, _b, _1) ])
                > "@" > +(( "$0" > constant [ boost::phoenix::bind(&msvc_name::add_template_constant_dependent_writer, this, _a, _b, _1) ])
                    | type [ boost::phoenix::bind(&msvc_name::add_template_type_dependent_writer, this, _a, _b, _1) ])
                >> eps [ boost::phoenix::bind(&msvc_name::finish_template_dependent_writer, this, _val, _a, _b) ])
            | ("@" > dependent_identifier [ boost::phoenix::bind(&msvc_name::dependent_writer, this, _val, _1) ]))
            ;
        BOOST_SPIRIT_DEBUG_NODE(start);
        start.name("msvc_name");
        on_error<boost::spirit::qi::fail, iterator>(start,
            cerr << boost::phoenix::val("Parsing error: Expected ") << _4 << boost::phoenix::val(" here: \"")
                << boost::phoenix::construct<string>(_3, _2) << boost::phoenix::val("\"") << endl);
    }

    rule<iterator, SymbolType(), locals<SymbolType, string>> start;
    rule<iterator, string()> identifier, template_dependent_identifier, dependent_identifier;
    msvc_type type;
    msvc_constant<iterator> constant;
};

您会注意到“lit("@@") >> eps”，我试图让它在看到 @@ 后停止匹配。现在这里是应该匹配一个完整的错位符号的部分:

template<typename iterator> struct msvc_symbol : grammar<iterator, SymbolType()>
{
    SymbolTypeDict &typedict;
    /* The key to Microsoft symbol mangles is the operator '@@' which consists of a preamble
    and a postamble. Immediately following the '@@' operator is:
    Variable:
    3<type><storage class>
    Static member variable:
    2<type><storage class>
    Function:
    <near|far><calling conv>[<stor ret>]   <return type>[<parameter type>...]<term>Z
    <Y   |Z  ><A|E|G       >[<?A|?B|?C|?D>]<MangledToSymbolTypeType...>      <@>Z
    Member Function:
    <protection>[<const>]<calling conv>[<stor ret>]   <return type>[<parameter type>...]<term>Z
    <A-V       >[<A-D>  ]<A|E|G       >[<?A|?B|?C|?D>]<MangledToSymbolTypeType...>      <@>Z
    */
    msvc_symbol(SymbolTypeDict &_typedict) : msvc_symbol::base_type(start), typedict(_typedict), name(_typedict), variable(_typedict)
    {
        start="?" >> name >> ("@@" >> variable);
        BOOST_SPIRIT_DEBUG_NODE(start);
        on_error<boost::spirit::qi::fail, iterator>(start,
            cerr << boost::phoenix::val("Parsing error: Expected ") << _4 << boost::phoenix::val(" here: \"")
                << boost::phoenix::construct<string>(_3, _2) << boost::phoenix::val("\"") << endl);
    }

    rule<iterator, SymbolType()> start;
    msvc_name<iterator> name;
    msvc_variable<iterator> variable;
};

所以，它匹配“？”很容易;)。问题是它在“？”之后发送所有内容。到 msvc_name 解析器，所以不是从 @@ 开始的位进入 msvc_variable，其余部分进入 msvc_name，msvc_name 消耗所有直到并包括 @@。这不直观，因为人们会认为括号意味着先做那件事。

因此，如果我更换:
开始=？ >> 名称 >> ("@@">> 变量);
和
开始=？ >> 名称 >> 变量；
...一切正常。

但是我真的不想这样做。理想情况下，我希望 Boost.Spirit 在 msvc_symbol 中在 @@ 处干净地拆分，并按原样“做正确的事”。我在想我可能没有足够的递归思考？无论哪种方式，我都很难过。

注意:是的，我知道我可以在@@ 处断开字符串并运行两个单独的解析器。这不是我要问的 - 相反，我是在问如何配置 Boost.Spirit 以在开始之前解析短语的结尾。

另请注意:我知道 skipper 可以用来制作@@ 空格并以这种方式进行拆分。问题是@@ 之前的内容非常具体，@@ 之后的内容也是如此。因此它不是真正的空白。

非常感谢任何可以提供帮助的人。从谷歌和 Stackoverflow 上搜索与此相关的问题，克服 Boost.Spirit 的“从左到右的贪婪”是很多人的问题。

尼尔

Answer 1

看起来你可以做很多事情:

1. 明确禁止在您希望使用“@”的地方使用双“@@”。另见

   • http://www.boost.org/doc/libs/1_52_0/libs/spirit/doc/html/spirit/qi/reference/operator/difference.html
   • http://www.boost.org/doc/libs/1_52_0/libs/spirit/doc/html/spirit/qi/reference/operator/not_predicate.html

2. 先标记化(使用 Spirit Lex？)

在这里，我将向您展示第一种方法的一个工作示例:

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/karma.hpp>
namespace qi = boost::spirit::qi;

template<typename T> T reversed(T c) {  return T(c.rbegin(), c.rend()); }

int main (int argc, char** argv)
{
    const std::string input("?myvolatileStaticMember@myclass@@2HC");

    auto f = begin(input), l = end(input);

    auto identifier = +~qi::char_("@");
    auto delimit    = qi::lit("@") - "@@";

    std::vector<std::string> qualifiedName;
    std::string typeId;

    if (qi::parse(f,l,
                '?' >> identifier % delimit >> "@@" >> +qi::char_,
                qualifiedName,
                typeId))
    {
        using namespace boost::spirit::karma;
        qualifiedName = reversed(qualifiedName);
        std::cout << "Qualified name: "  << format(auto_ % "::" << "\n", qualifiedName);
        std::cout << "Type indication: '" << typeId << "'\n";
    }
}

输出:

Qualified name: myclass::myvolatileStaticMember
Type indication: '2HC'