解析精神氣中的嵌套層次結構-無法正確獲得語法

Question

我的精神::氣喘吁吁，需要幫助。 我正在嘗試解析以下形式的短語：

( wheels=4 & chassis=metal & engine=( cylinders=8 & volume=6209 ) )

...成為嵌套結構：

class dict : public std::map<std::string, boost::variant<dict, std::string>>

...其中car_dict [“ wheels”]返回“ 4”，而car_dict [“ engine”]返回另一個dict，其中engine_dict [“ cylinders”]返回“ 8”。

這是我的語法，我希望有豐富經驗的人可以指出我要去的地方。

struct qi_car_grammar : qi::grammar<std::string::const_iterator, dict()>
{
    qi::rule<std::string::const_iterator, dict()> car_dict;
    qi::rule<std::string::const_iterator, std::string()> car_key;
    qi::rule<std::string::const_iterator, boost::variant<dict, std::string>()> car_variant_value;

    qi_car_grammar()
        : qi_car_grammar::base_type(car_dict)
    {
        // RULES
        car_key %= *(qi::lit(' ')) >> *(~qi::lit('='));

        car_variant_value %= car_dict | *(~qi::char_("&)"));

        car_dict = qi::lit('(')
            >> car_key >> qi::lit('=') >> car_variant_value
            >> *(qi::lit('&') >> car_key >> qi::lit('=') >> car_variant_value)
            >> qi::lit(')');
    }
}

任何幫助表示贊賞。 在有人建議之前，不，我對要解析的結構沒有太多控制權。

Answer 1

嗯。 我只是做了一般的清理通行證¹。

您已經很接近了。

您可能只是缺少了boost/fusion/adapted/std_pair.hpp標頭，這是將解析的元組自動轉換為std::pair<K,V>所必需的。

這是工作示例（我花了很多時間來創建dict漂亮打印機...）：

生活在Coliru

#include <boost/fusion/adapted/std_pair.hpp>
#include <boost/spirit/include/qi.hpp>
#include <map>

namespace qi = boost::spirit::qi;

class dict : public std::map<std::string, boost::variant<dict, std::string>>
{
};

template <typename It = std::string::const_iterator, typename Skipper = qi::space_type>
struct qi_car_grammar : qi::grammar<It, dict(), Skipper>
{
    qi_car_grammar()
        : qi_car_grammar::base_type(car_dict)
    {
        // RULES
        car_key   = *~qi::char_("=");
        car_value = *~qi::char_("&)");

        car_variant_value = car_dict | car_value;

        car_dict = '(' >> (car_key >> '=' >> car_variant_value) % '&' >> ')';
    }

  private:
    qi::rule<It, dict(), Skipper> car_dict;
    qi::rule<It, std::string()> car_key, car_value;
    qi::rule<It, boost::variant<dict, std::string>(), Skipper> car_variant_value;
};

// for debug
static inline std::ostream& operator<<(std::ostream& os, dict const& d) {
    struct vis {
        using result_type = void;
        std::ostream& _os;
        std::string indent;

        void operator()(std::string const& s) const { _os << s; }
        void operator()(dict const& d) const { 
            _os << "(\n";
            for (auto& entry: d) {
                _os << indent << "    " << entry.first << " = ";
                boost::apply_visitor(vis{_os, indent+"    "}, entry.second);
                _os << "\n";
            }
            _os << indent << ")\n";
        }
    } v { os, "" };

    v(d);
    return os;
}

int main()
{
    std::string const input = "( wheels=4 & chassis=metal & engine=( cylinders=8 & volume=6209 ) )";

    dict parsed;
    qi_car_grammar<> g;

    auto f = input.begin(), l = input.end();
    bool ok = qi::phrase_parse(f, l, g, qi::space, parsed);

    if (ok)
        std::cout << "Parsed: " << parsed << "\n";
    else
        std::cout << "Parsed failed\n";

    if (f!=l)
        std::cout << "Remaining unparsed: '" << std::string(f,l) << "'\n";
}

打印：

Parsed: (
    chassis = metal 
    engine = (
        cylinders = 8 
        volume = 6209 
    )

    wheels = 4 
)

---

¹（就像我在閱讀代碼示例時一樣，這有助於我的理解）