无法从 Boost.Spirit 中的占位符构造 std::string

Question

我已经开始研究基于 Boost.Spirit 的简单解析器，它将解析类似 C++ 的文件（唯一的 C++-ish 部分是内置模板类型；例如 map<string, smart_ptr<int>> name_object_map; - 但是这是编译器内置的，用户不能声明模板classes）。尽管如此，语法旨在包含数据结构声明，而不是表达式，除了用于枚举器声明初始化的常量表达式； enum E { a = 4 * 5 + 3 }; 有效。目前这对我来说不是问题，因为我还不能按照我想要的方式解析 E :)

我昨天在阅读文档和示例后做了以下内容，但它没有编译：

#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/qi_char_class.hpp>
#include <cassert>
#include <memory>
#include <string>
#include <utility>

struct context {};

class foo {
  std::string name;
  const context *ctx;

public:
  foo(const std::string &name, const context *ctx) : name(name), ctx(ctx) {}
};

using foo_ref = std::shared_ptr<foo>;

template <typename Iterator>
struct skipper : boost::spirit::qi::grammar<Iterator> {
  skipper() : skipper::base_type(start) {
    using namespace boost::spirit;
    qi::char_type char_;
    ascii::space_type space;

    start = space                             // tab/space/cr/lf
            | "/*" >> *(char_ - "*/") >> "*/" // C-style comments
        ;
  }

  boost::spirit::qi::rule<Iterator> start;
};

template <typename Iterator>
struct the_parser : boost::spirit::qi::grammar<Iterator, std::vector<foo_ref>(),
                                               skipper<Iterator>> {
  the_parser() : the_parser::base_type(start), current_context(&root) {
    using namespace boost::spirit;
    namespace phx = boost::phoenix;

    identifier = qi::lexeme[qi::alpha >> *qi::alnum];
    start = *(foo_decl); // currently, no semantic action attached.
                         // This will create the root decl in ast.

    foo_decl = (lit("foo") >> identifier)[qi::_val = std::make_shared<foo>(
                                               qi::_1, current_context)] >>
               qi::char_('{') >> qi::char_('}') >> qi::char_(';');
    BOOST_SPIRIT_DEBUG_NODES((identifier)(start)(foo_decl));
  }
  boost::spirit::qi::rule<Iterator, std::string(), skipper<Iterator>>
      identifier;
  boost::spirit::qi::rule<Iterator, std::vector<foo_ref>(), skipper<Iterator>>
      start;
  boost::spirit::qi::rule<Iterator, foo_ref(), skipper<Iterator>> foo_decl;
  context root;
  const context *current_context;
};

int main() {
  the_parser<std::string::const_iterator> parser;
  std::vector<foo_ref> root;

  const std::string content = "foo john_doe { };";
  auto first = content.cbegin(), last = content.cend();
  bool r = boost::spirit::qi::phrase_parse(
      first, last, parser, skipper<std::string::const_iterator>(), root);
  assert(r && first == last);
}

在 Mac 上用 clang 编译它（第一行是 std::make_shared）：

error: no matching constructor for initialization of 'foo'
          __second_(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
          ^         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
...
note: candidate constructor not viable: no known conversion from 'const boost::phoenix::actor<boost::spirit::argument<0> >' to 'const std::string' (aka
  'const basic_string<char, char_traits<char>, allocator<char> >') for 1st argument
  foo(const std::string &name, const context *ctx) : name(name), ctx(ctx) {}
  ^

在foo_decl的语义动作中，无法构造foo（通过std::make_shared），因为第一个属性的结果无法转换为std::string。但是，如果我添加一个 class 成员 std::string s，并改为执行此操作，它会起作用：

foo_decl = (lit("foo") >> identifier)[boost::phoenix::ref(s) = qi::_1] >>
                 qi::char_('{') >> qi::char_('}') >> qi::char_(';');

同样，如果我尝试 std::cout 它，我可以看到打印了 john_doe。

如果我用phoenix绑定一个成员函数调用，也可以：

foo_decl = (lit("foo") >> identifier)[qi::_val =
                   boost::phoenix::bind(&the_parser, this, qi::_1)] >>
           qi::char_('{') >> qi::char_('}') >> qi::char_(';');

foo_ref make_foo(const std::string &n) {
  return std::make_shared(n, current_context);
}

这最后三个解决方法意味着存在从 decltype(qi::_1) 到 std::string 的隐式转换序列；这不对吗？

如果你能告诉我我的错误或我对语义动作和占位符如何工作的理解上的差距，我将非常高兴。我很奇怪为什么 std::make_shared 不起作用。

谢谢！

Answer 1

首先：

我会避开 Spirit 中的智能指针
- How can I use polymorphic attributes with boost::spirit::qi parsers?
如果你不需要语义动作（你不需要）我会避开它们Boost Spirit: "Semantic actions are evil"?
问题出在占位符上：不能静态使用，需要在惰性表达式中使用（凤凰演员）

使用第一个 link 中的 phoenix::function:

Live On Coliru

#define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/include/qi.hpp>
#include <cassert>
#include <memory>
#include <string>
#include <utility>

namespace {
    template <typename T> struct make_shared_f {
        template <typename... A> struct result { typedef std::shared_ptr<T> type; };

        template <typename... A> typename result<A...>::type operator()(A &&... a) const {
            return std::make_shared<T>(std::forward<A>(a)...);
        }
    };

    template <typename T> using make_shared_ = boost::phoenix::function<make_shared_f<T> >;
}

struct context {};

class foo {
    std::string name;
    const context *ctx;

  public:
    foo(const std::string &name, const context *ctx) : name(name), ctx(ctx) {}
};

using foo_ref = std::shared_ptr<foo>;

template <typename Iterator> struct skipper : boost::spirit::qi::grammar<Iterator> {
    skipper() : skipper::base_type(start) {
        using namespace boost::spirit;
        qi::char_type char_;
        ascii::space_type space;

        start = space                             // tab/space/cr/lf
                | "/*" >> *(char_ - "*/") >> "*/" // C-style comments
            ;
    }

    boost::spirit::qi::rule<Iterator> start;
};

template <typename Iterator>
struct the_parser : boost::spirit::qi::grammar<Iterator, std::vector<foo_ref>(), skipper<Iterator> > {
    the_parser() : the_parser::base_type(start), current_context(&root) {
        using namespace boost::spirit;
        namespace phx = boost::phoenix;

        identifier = qi::alpha >> *qi::alnum;
        // This will create the root decl in ast.

        foo_decl = ("foo" >> identifier) [qi::_val = make_shared_<foo>{}(qi::_1, current_context)] >>
                   '{' >> '}' >> ';';

        start      = *foo_decl; // currently, no semantic action attached.
        BOOST_SPIRIT_DEBUG_NODES((identifier)(start)(foo_decl));
    }
    boost::spirit::qi::rule<Iterator, std::string()> identifier;
    boost::spirit::qi::rule<Iterator, foo_ref(), skipper<Iterator> > foo_decl;
    boost::spirit::qi::rule<Iterator, std::vector<foo_ref>(), skipper<Iterator> > start;
    context root;
    const context *current_context;
};

int main() {
    the_parser<std::string::const_iterator> parser;
    std::vector<foo_ref> root;

    const std::string content = "foo johndoe { };";
    auto first = content.cbegin(), last = content.cend();
    bool r = boost::spirit::qi::phrase_parse(first, last, parser, skipper<std::string::const_iterator>(), root);
    if (r)
        std::cout << "success\n";
    else
        std::cout << "failed\n";

    if (first != last)
        std::cout << "remaining unparsed: '" << std::string(first,last) << "'\n";

}

版画

success

连同

的调试输出

<start>
  <try>foo johndoe { };</try>
  <foo_decl>
    <try>foo johndoe { };</try>
    <identifier>
      <try>johndoe { };</try>
      <success> { };</success>
      <attributes>[[j, o, h, n, d, o, e]]</attributes>
    </identifier>
    <success></success>
    <attributes>[0x60600000ebb0]</attributes>
  </foo_decl>
  <foo_decl>
    <try></try>
    <fail/>
  </foo_decl>
  <success></success>
  <attributes>[[0x60600000ebb0]]</attributes>
</start>

无法从 Boost.Spirit 中的占位符构造 std::string

cannot construct std::string from placeholder in Boost.Spirit

c++

boost-spirit

boost-spirit-qi