【发布时间】：2016-10-06 19:11:21
【问题描述】：
我想写一个可以使用的解析器（作为qi扩展）
via my_parser(p1, p2, ...) 其中p1, p2, ... 是qi 解析器表达式。
实际上，我想实现一个 best_matchparser ，它的工作原理类似于 qi 替代方案，但不是选择第一个匹配规则，而是选择“解释”大部分输入的规则。
给定两个规则simple_id = +(qi::alpha) 和complex_id = simple_id >> *(qi::string("::") > simple_id)，它将在输入willy::anton 上选择complex_id。并且这样做不会产生中间属性。这些好处可以通过运行时得到回报，因为需要先行解析。
在我看来，这种解析器构造有几个用例。 benchmark(p1, ...) 作为优化的支持解析器，仅举一个例子。一旦我知道如何提供，我会提供。
这个解析器将是一个非终端。我尝试了（努力），但我无法在 qi 中找到我的问题的答案。我的猜测是，C++ 机制与 c qi 紧密集成，以至于没有可以理解的入口点，至少对我来说是这样。
很容易实现我想要引入运算符的内容。我在下面附加了当前的解决方案。它按预期编译，但不完整。
qi 操作符得到一个 fusion::vector/sequence (whatever) 现成的并对其进行操作。似乎没有图书馆产品可以解决我的问题。甚至 make_nary_composite 已经期望将 args 编译为 Elements。
我尝试了很多，但都失败了，所以我不想让你厌烦。
我可以想象的一种解决方法是提供一个有状态运算符,，这将使p1, ... 成为合法的qi 表达式。然后实现一个 unary_parser best_match 或指令来处理该表达式。
, 将获得两种模式：获取当前（成功）解析器消耗的输入长度，并实际解析阶段 1 中选定的输入。包装器首先在模式 1 中运行逗号解析器，然后在模式 2 中运行。它可能很丑，但可以工作。
运算符实现 p1 |= p2 |= ... 对于 n > 2 的运行时而言是最昂贵的。我很乐意解决这个问题。
最小（但仍然是合理的）开销将有best_match(p1, ...)。
这有可能吗？
因为我对 boost::fusion 不太熟悉，所以我也在代码中添加了一些问题（关于 fusion 的方法）。
感觉不对，将实际上是一个三元非终端解析器的东西压入一元解析器方案。但由于我的理解很差，这似乎是完成它的唯一方法。我非常感谢任何帮助我摆脱困境的帮助。
我的环境：Boost 1.61，MSVC 2015 Upd 2，目标 win32console。
进展：
我认为，我正在缓慢但肯定地得到它。我很高兴看到error_invalid_expression。由于以下 proto 表达式，编译失败：
boost::proto::exprns_::expr<
boost::proto::tagns_::tag::function,boost::proto::argsns_::list5<
const boost::proto::exprns_::expr<
boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<
mxc::qitoo::tag::best_match
>
,0> &
,const boost::spirit::qi::rule<
iterator_type,std::string (void),
boost::spirit::standard::space_type,
boost::spirit::unused_type,boost::spirit::unused_type> &
,const boost::spirit::qi::rule<
iterator_type,std::string (void),
boost::spirit::standard::space_type,
boost::spirit::unused_type,
boost::spirit::unused_type> &
, const boost::spirit::qi::rule<
iterator_type,std::string (void),
boost::spirit::standard::space_type,
boost::spirit::unused_type,
boost::spirit::unused_type> &
,const boost::spirit::qi::rule<
iterator_type,std::string (void),
boost::spirit::standard::space_type,
boost::spirit::unused_type,
boost::spirit::unused_type> &
>
,5>
这实际上是描述我的 best_match 解析器的函数样式用法的表达式。我的测试规则看起来像
qitoo::best_match(id, qualified_id, id, qualified_id)
其中id 和qualified_id 是上面提到的规则。我想要的一切。
发生错误是因为此表达式没有成员 parse。好的。深入挖掘，我发现 qi 的元编译器确实支持一元、二元和一元（即可变参数）解析器。但它不支持函数样式语法。 Qi 似乎仅将一元、二元和一元用于运算符。虽然支持 nary 类型，但它或多或少已经过时了，因为 qi 运算符是二元最大值。
结束进度编辑
#include <boost/spirit/home/qi.hpp>
namespace boost {
namespace spirit
{
///////////////////////////////////////////////////////////////////////////
// Enablers
///////////////////////////////////////////////////////////////////////////
template <>
struct use_operator<qi::domain, proto::tag::bitwise_or_assign> // enables |=
: mpl::true_ {};
template <>
struct flatten_tree<qi::domain, proto::tag::bitwise_or_assign> // flattens |=
: mpl::true_ {};
}
}
namespace mxc {
namespace qitoo {
namespace spirit = boost::spirit;
namespace qi = spirit::qi;
namespace fusion = boost::fusion;
template <typename Elements>
struct best_match_parser : qi::nary_parser<mxc::qitoo::best_match_parser<Elements>>
{
// This one does a lookahead parse of each qi expression to find out which rule matches
// most of the input
template <typename Iterator, typename Context, typename Skipper>
struct best_function
{
best_function(Iterator& first, Iterator const& last, Context& context,
Skipper const& skipper, int& best, int& idx, int& size)
: first(first), last(last), context(context), skipper(skipper), best(best),
idx(idx), size(size) {};
template <typename Component>
void operator()(Component& component) const
{
Iterator f = first;
if (component.parse(f, last, context, skipper, qi::unused)) {
// please have a look on how I transport best, idx and size
// into the parser context
//
// I guess, this is a nasty hack and could be done better
// Any advice would be highliy appreciated
int l = f - first;
if (l > size) {
size = l;
best = idx++;
}
idx++;
}
}
private:
int& best;
int& idx;
int& size;
Iterator& first;
Iterator const& last;
Context& context;
Skipper const& skipper;
};
template <typename Context, typename Iterator>
struct attribute
{
// Put all the element attributes in a tuple
typedef typename spirit::traits::build_attribute_sequence <
Elements, Context, spirit::traits::alternative_attribute_transform
, Iterator, qi::domain
>::type all_attributes;
// Ok, now make a variant over the attribute sequence. Note that
// build_variant makes sure that 1) all attributes in the variant
// are unique 2) puts the unused attribute, if there is any, to
// the front and 3) collapses single element variants, variant<T>
// to T.
typedef typename
spirit::traits::build_variant<all_attributes>::type
type;
};
best_match_parser(Elements const& elements_) : elements(elements_), size(0), idx(0), best(-1) {}
template <typename Iterator, typename Context, typename Skipper, typename Attribute>
bool parse(Iterator& first, Iterator const& last
, Context& context, Skipper const& skipper
, Attribute& attr_) const
{
best_function<Iterator, Context, Skipper> f(first, last, context, skipper, best, idx, size);
// find out which parser matches most of the input
fusion::for_each(elements, f);
// best >= 0 if at least one parser was successful
if (best >= 0) {
// now that I have the best parser identified, how do I access it?
// I understand that the next line can not work, but I'm looking for something like that
// --> auto v = fusion::at<boost::mpl::int_<best>>(elements);
};
return false;
}
template <typename Context>
qi::info what(Context& context) const
{
qi::info result("best_match");
fusion::for_each(elements,
spirit::detail::what_function<Context>(result, context));
return result;
}
Elements elements;
mutable int best;
mutable int idx;
mutable int size;
};
}
}
namespace boost {
namespace spirit {
namespace qi {
///////////////////////////////////////////////////////////////////////////
// Parser generators: make_xxx function (objects)
///////////////////////////////////////////////////////////////////////////
template <typename Elements, typename Modifiers>
struct make_composite<proto::tag::bitwise_or_assign, Elements, Modifiers>
: make_nary_composite < Elements, mxc::qitoo::best_match_parser >
{};
}
namespace traits {
///////////////////////////////////////////////////////////////////////////
template <typename Elements>
struct has_semantic_action<mxc::qitoo::best_match_parser<Elements> >
: nary_has_semantic_action<Elements> {};
///////////////////////////////////////////////////////////////////////////
template <typename Elements, typename Attribute, typename Context
, typename Iterator>
struct handles_container<mxc::qitoo::best_match_parser<Elements>, Attribute, Context
, Iterator>
: nary_handles_container<Elements, Attribute, Context, Iterator> {};
}
}
}
namespace qi = boost::spirit::qi;
namespace qitoo = mxc::qitoo;
using iterator_type = std::string::const_iterator;
using result_type = std::string;
template<typename Parser>
void parse(const std::string message, const std::string& input, const std::string& rule, const Parser& parser) {
iterator_type iter = input.begin(), end = input.end();
std::vector<result_type> parsed_result;
std::cout << "-------------------------\n";
std::cout << message << "\n";
std::cout << "Rule: " << rule << std::endl;
std::cout << "Parsing: \"" << input << "\"\n";
bool result = qi::phrase_parse(iter, end, parser, qi::space, parsed_result);
if (result)
{
std::cout << "Parser succeeded.\n";
std::cout << "Parsed " << parsed_result.size() << " elements:";
for (const auto& str : parsed_result)
std::cout << "[" << str << "]";
std::cout << std::endl;
}
else
{
std::cout << "Parser failed" << std::endl;
}
if (iter == end) {
std::cout << "EOI reached." << std::endl;
}
else {
std::cout << "EOI not reached. Unparsed: \"" << std::string(iter, end) << "\"" << std::endl;
}
std::cout << "-------------------------\n";
}
int main()
{
namespace qi = boost::spirit::qi;
qi::rule < iterator_type, std::string(), qi::space_type>
id = (qi::alpha | qi::char_('_')) >> *(qi::alnum | qi::char_('_'));
qi::rule < iterator_type, std::string(), qi::space_type>
qualified_id = id >> *(qi::string("::") > id);
namespace qitoo = mxc::qitoo;
namespace qi = boost::spirit::qi;
parse("best match operator, select second rule"
, "willy::anton::lutz"
, "id |= qualified_id"
, id |= qualified_id);
}
【问题讨论】：
-
找到了一个解决方案，但涉及修改 qi 的元编译器和 make_component 部分。如果有其他解决方案我没有设法找出。我对自己的非标准 qi 不太满意。
标签： c++ parsing boost boost-spirit boost-spirit-qi