我已经开始研究一个基于Boost.Spirit的简单解析器,它将解析一个类似C++的文件(唯一C++的部分是内置的模板类型;例如 map<string, smart_ptr<int>> name_object_map;
- 但这是编译器内置的,用户无法声明模板类)。尽管如此,语法旨在包含数据结构声明,而不是表达式,但用于初始化枚举器声明的常量表达式除外; 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
。但是,如果我添加一个类成员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
不起作用,这看起来很奇怪。
谢谢!
首先:
-
我会在精神中引导克莱尔的智能指针
-
从灵气中制作共享指针的矢量
-
如何将多态属性与 boost::spirit::qi 解析器一起使用?
如果你不需要语义行为(你不需要 -
),我会避开它们(你不需要) 提升精神:"语义行为是邪恶的"?
问题出在占位符上:你不能静态使用它,你需要在懒惰的表达式中使用它(凤凰演员)
使用第一个链接中的 phoenix::函数:
住在科里鲁
#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 << "successn";
else
std::cout << "failedn";
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>