Boost 将Spirit标记化表达式增强为向量
我试图解析一个表达式,该表达式也可以包含标识符,并将每个元素推送到Boost 将Spirit标记化表达式增强为向量,boost,boost-spirit,boost-phoenix,Boost,Boost Spirit,Boost Phoenix,我试图解析一个表达式,该表达式也可以包含标识符,并将每个元素推送到std::vector,我提出了以下语法: #include <boost/spirit/include/qi.hpp> #include <boost/spirit/include/phoenix_core.hpp> #include <boost/spirit/include/phoenix_operator.hpp> #include <vector> namespace q
std::vector
,我提出了以下语法:
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <vector>
namespace qi = boost::spirit::qi;
struct Tokeniser
: boost::spirit::qi::grammar <std::string::const_iterator, std::vector <std::string> (), boost::spirit::ascii::space_type>
{
Tokeniser() : Tokeniser::base_type(expression)
{
namespace qi = boost::spirit::qi;
expression =
term >>
*( (qi::string("+")[qi::_val.push_back(qi::_1)] >> term) |
(qi::string("-")[qi::_val.push_back(qi::_1)] >> term) );
term =
factor >>
*( (qi::string("*")[qi::_val.push_back(qi::_1)] >> factor) |
(qi::string("/")[qi::_val.push_back(qi::_1)] >> factor) );
factor =
(identifier | myDouble_)[qi::_val.push_back(qi::_1)] |
qi::string("(")[qi::_val.push_back(qi::_1)] >> expression >> qi::string(")")[qi::_val.push_back(qi::_1)];
identifier = qi::raw [ qi::lexeme[ (qi::alpha | '_') >> *(qi::alnum | '_') ] ];
myDouble_ = qi::raw [ qi::double_ ];
}
boost::spirit::qi::rule<std::string::const_iterator, std::vector <std::string> (), boost::spirit::ascii::space_type> expression;
boost::spirit::qi::rule<std::string::const_iterator, boost::spirit::ascii::space_type> factor;
boost::spirit::qi::rule<std::string::const_iterator, boost::spirit::ascii::space_type> term;
boost::spirit::qi::rule<std::string::const_iterator, std::string(), boost::spirit::ascii::space_type> identifier;
boost::spirit::qi::rule<std::string::const_iterator, std::string(), boost::spirit::ascii::space_type> myDouble_;
};
#包括
#包括
#包括
#包括
名称空间qi=boost::spirit::qi;
结构标记器
:boost::spirit::qi::语法
{
Tokeniser():Tokeniser::base_类型(表达式)
{
名称空间qi=boost::spirit::qi;
表达式=
术语>>
*((qi::字符串(“+”[qi::_val.push_back(qi::_1)]>>术语)|
(qi::字符串(“-”[qi::_val.push_back(qi:_1)]>>术语));
术语=
因子>>
*((qi::字符串(“*”[qi::_val.push_back(qi::_1)]>>因子)|
(qi::字符串(“/”[qi::_val.push_back(qi::_1)]>>因子);
因素=
(标识符| myDouble)[qi::_val.push_back(qi::_1)]|
qi::string(“”[qi::_val.push_back(qi::_1)]>>表达式>>qi::string(“”)[qi:_val.push_back(qi:_1)];
identifier=qi::raw[qi::lexeme[(qi::alpha |'')>*(qi::alnum |'')];
myDouble=qi::raw[qi::double];
}
boost::spirit::qi::规则表达式;
提振::精神::气::规则因素;
提振::精神::气::规则术语;
boost::spirit::qi::规则标识符;
提振::精神::气::规则myDouble;
};
但是,我得到以下错误“const struct boost::phoenix::actor”没有名为“push_back”的成员
有没有直接的方法来执行我想做的事情?是的,占位符类型(显然)没有push_back
成员
C++是强类型的。任何延迟的操作都是一种“幻觉”:参与者通过组合特殊用途的类型在表达式模板中表示,这些类型可以在以后进行“评估”
表达式模板简介
#define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/phoenix/stl.hpp>
#include <vector>
namespace qi = boost::spirit::qi;
namespace px = boost::phoenix;
template <typename It = std::string::const_iterator>
struct Tokeniser
: qi::grammar <It, std::vector <std::string> (), boost::spirit::ascii::space_type>
{
Tokeniser() : Tokeniser::base_type(expression)
{
auto push = px::push_back(qi::_val, qi::_1);
auto propagate = px::insert(qi::_val, px::end(qi::_val), px::begin(qi::_1), px::end(qi::_1));
expression =
term[propagate] >>
*( (qi::string("+")[push] >> term[propagate]) |
(qi::string("-")[push] >> term[propagate]) );
term =
factor[propagate] >>
*( (qi::string("*")[push] >> factor[propagate]) |
(qi::string("/")[push] >> factor[propagate]) );
factor =
(identifier | myDouble_)[push] |
qi::string("(")[push] >> expression[propagate] >> qi::string(")")[push];
identifier = qi::raw [ qi::lexeme[ (qi::alpha | '_') >> *(qi::alnum | '_') ] ];
myDouble_ = qi::raw [ qi::double_ ];
BOOST_SPIRIT_DEBUG_NODES((expression)(term)(factor)(identifier)(myDouble_))
}
qi::rule<It, std::vector<std::string>(), boost::spirit::ascii::space_type> expression;
qi::rule<It, std::vector<std::string>(), boost::spirit::ascii::space_type> factor;
qi::rule<It, std::vector<std::string>(), boost::spirit::ascii::space_type> term;
qi::rule<It, std::string(), boost::spirit::ascii::space_type> identifier;
qi::rule<It, std::string(), boost::spirit::ascii::space_type> myDouble_;
};
int main() {
Tokeniser<> tok;
std::string const input = "x + 89/(y*y)";
auto f = input.begin(), l = input.end();
std::vector<std::string> tokens;
if (phrase_parse(f, l, tok, boost::spirit::ascii::space, tokens)) {
std::cout << "Parsed " << tokens.size() << " tokens:\n";
for (auto& token : tokens)
std::cout << " - '" << token << "'\n";
} else {
std::cout << "Parse failed\n";
}
if (f != l)
std::cout << "Remaining unparsed input: '" << std::string(f,l) << "'\n";
}
#define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
#include <vector>
namespace qi = boost::spirit::qi;
template <typename It = std::string::const_iterator>
struct Tokeniser : qi::grammar <It, std::vector <std::string>()> {
Tokeniser() : Tokeniser::base_type(start)
{
start = qi::skip(boost::spirit::ascii::space) [expression];
expression =
term >>
*( (qi::string("+") >> term) |
(qi::string("-") >> term) );
term =
factor >>
*( (qi::string("*") >> factor) |
(qi::string("/") >> factor) );
factor =
(identifier | myDouble_) |
qi::string("(") >> expression >> qi::string(")");
identifier = qi::raw [ (qi::alpha | '_') >> *(qi::alnum | '_') ];
myDouble_ = qi::raw [ qi::double_ ];
BOOST_SPIRIT_DEBUG_NODES((expression)(term)(factor)(identifier)(myDouble_))
}
qi::rule<It, std::vector<std::string>()> start;
qi::rule<It, std::vector<std::string>(), boost::spirit::ascii::space_type> expression, factor, term;
qi::rule<It, std::string()> identifier, myDouble_;
};
int main() {
Tokeniser<> tok;
std::string const input = "x + 89/(y*y)";
auto f = input.begin(), l = input.end();
std::vector<std::string> tokens;
if (parse(f, l, tok, tokens)) {
std::cout << "Parsed " << tokens.size() << " tokens:\n";
for (auto& token : tokens)
std::cout << " - '" << token << "'\n";
} else {
std::cout << "Parse failed\n";
}
if (f != l)
std::cout << "Remaining unparsed input: '" << std::string(f,l) << "'\n";
}
以防你想了解它的实际工作原理,这是一个从头开始的简单例子。注释描述了代码的各个部分的功能:
// we have lazy placeholder types:
template <int N> struct placeholder {};
placeholder<1> _1;
placeholder<2> _2;
placeholder<3> _3;
// note that every type here is stateless, and acts just like a more
// complicated placeholder.
// We can have expressions, like binary addition:
template <typename L, typename R> struct addition { };
template <typename L, typename R> struct multiplication { };
// here is the "factory" for our expression template:
template <typename L, typename R> addition<L,R> operator+(L const&, R const&) { return {}; }
template <typename L, typename R> multiplication<L,R> operator*(L const&, R const&) { return {}; }
///////////////////////////////////////////////
// To evaluate/interpret the expressions, we have to define "evaluation" for each type of placeholder:
template <typename Ctx, int N>
auto eval(Ctx& ctx, placeholder<N>) { return ctx.arg(N); }
template <typename Ctx, typename L, typename R>
auto eval(Ctx& ctx, addition<L, R>) { return eval(ctx, L{}) + eval(ctx, R{}); }
template <typename Ctx, typename L, typename R>
auto eval(Ctx& ctx, multiplication<L, R>) { return eval(ctx, L{}) * eval(ctx, R{}); }
///////////////////////////////////////////////
// A simple real-life context would contain the arguments:
#include <vector>
struct Context {
std::vector<double> _args;
// define the operation to get an argument from this context:
double arg(int i) const { return _args.at(i-1); }
};
#include <iostream>
int main() {
auto foo = _1 + _2 + _3;
Context ctx { { 3, 10, -4 } };
std::cout << "foo: " << eval(ctx, foo) << "\n";
std::cout << "_1 + _2 * _3: " << eval(ctx, _1 + _2 * _3) << "\n";
}
确定行动:
您必须“描述”push_back
操作,而不是试图在占位符上找到这样的操作。凤凰城有你的背:
#include <boost/phoenix/stl.hpp>
但是,这还有一个额外的问题,\u val
被解析为规则的属性类型。但是您的一些规则没有声明属性类型,因此它默认为qi::unused_type
。显然,为该属性生成“push\u back”求值代码对于未使用的\u类型
不起作用
让我们修复这些声明:
qi::rule<It, std::vector<std::string>(), boost::spirit::ascii::space_type> expression;
qi::rule<It, std::vector<std::string>(), boost::spirit::ascii::space_type> factor;
qi::rule<It, std::vector<std::string>(), boost::spirit::ascii::space_type> term;
现在,使用
#define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/phoenix/stl.hpp>
#include <vector>
namespace qi = boost::spirit::qi;
namespace px = boost::phoenix;
template <typename It = std::string::const_iterator>
struct Tokeniser
: qi::grammar <It, std::vector <std::string> (), boost::spirit::ascii::space_type>
{
Tokeniser() : Tokeniser::base_type(expression)
{
auto push = px::push_back(qi::_val, qi::_1);
auto propagate = px::insert(qi::_val, px::end(qi::_val), px::begin(qi::_1), px::end(qi::_1));
expression =
term[propagate] >>
*( (qi::string("+")[push] >> term[propagate]) |
(qi::string("-")[push] >> term[propagate]) );
term =
factor[propagate] >>
*( (qi::string("*")[push] >> factor[propagate]) |
(qi::string("/")[push] >> factor[propagate]) );
factor =
(identifier | myDouble_)[push] |
qi::string("(")[push] >> expression[propagate] >> qi::string(")")[push];
identifier = qi::raw [ qi::lexeme[ (qi::alpha | '_') >> *(qi::alnum | '_') ] ];
myDouble_ = qi::raw [ qi::double_ ];
BOOST_SPIRIT_DEBUG_NODES((expression)(term)(factor)(identifier)(myDouble_))
}
qi::rule<It, std::vector<std::string>(), boost::spirit::ascii::space_type> expression;
qi::rule<It, std::vector<std::string>(), boost::spirit::ascii::space_type> factor;
qi::rule<It, std::vector<std::string>(), boost::spirit::ascii::space_type> term;
qi::rule<It, std::string(), boost::spirit::ascii::space_type> identifier;
qi::rule<It, std::string(), boost::spirit::ascii::space_type> myDouble_;
};
int main() {
Tokeniser<> tok;
std::string const input = "x + 89/(y*y)";
auto f = input.begin(), l = input.end();
std::vector<std::string> tokens;
if (phrase_parse(f, l, tok, boost::spirit::ascii::space, tokens)) {
std::cout << "Parsed " << tokens.size() << " tokens:\n";
for (auto& token : tokens)
std::cout << " - '" << token << "'\n";
} else {
std::cout << "Parse failed\n";
}
if (f != l)
std::cout << "Remaining unparsed input: '" << std::string(f,l) << "'\n";
}
#define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
#include <vector>
namespace qi = boost::spirit::qi;
template <typename It = std::string::const_iterator>
struct Tokeniser : qi::grammar <It, std::vector <std::string>()> {
Tokeniser() : Tokeniser::base_type(start)
{
start = qi::skip(boost::spirit::ascii::space) [expression];
expression =
term >>
*( (qi::string("+") >> term) |
(qi::string("-") >> term) );
term =
factor >>
*( (qi::string("*") >> factor) |
(qi::string("/") >> factor) );
factor =
(identifier | myDouble_) |
qi::string("(") >> expression >> qi::string(")");
identifier = qi::raw [ (qi::alpha | '_') >> *(qi::alnum | '_') ];
myDouble_ = qi::raw [ qi::double_ ];
BOOST_SPIRIT_DEBUG_NODES((expression)(term)(factor)(identifier)(myDouble_))
}
qi::rule<It, std::vector<std::string>()> start;
qi::rule<It, std::vector<std::string>(), boost::spirit::ascii::space_type> expression, factor, term;
qi::rule<It, std::string()> identifier, myDouble_;
};
int main() {
Tokeniser<> tok;
std::string const input = "x + 89/(y*y)";
auto f = input.begin(), l = input.end();
std::vector<std::string> tokens;
if (parse(f, l, tok, tokens)) {
std::cout << "Parsed " << tokens.size() << " tokens:\n";
for (auto& token : tokens)
std::cout << " - '" << token << "'\n";
} else {
std::cout << "Parse failed\n";
}
if (f != l)
std::cout << "Remaining unparsed input: '" << std::string(f,l) << "'\n";
}
大扫除
一般来说,避免语义动作(参见我的答案——特别是关于副作用的子弹)。大多数情况下,您可以不受自动属性传播的影响。我想说这是Boost Spirit的关键卖点
进一步简化跳过/lexemes()的操作确实可以显著减少代码和编译时间:
#define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/phoenix/stl.hpp>
#include <vector>
namespace qi = boost::spirit::qi;
namespace px = boost::phoenix;
template <typename It = std::string::const_iterator>
struct Tokeniser
: qi::grammar <It, std::vector <std::string> (), boost::spirit::ascii::space_type>
{
Tokeniser() : Tokeniser::base_type(expression)
{
auto push = px::push_back(qi::_val, qi::_1);
auto propagate = px::insert(qi::_val, px::end(qi::_val), px::begin(qi::_1), px::end(qi::_1));
expression =
term[propagate] >>
*( (qi::string("+")[push] >> term[propagate]) |
(qi::string("-")[push] >> term[propagate]) );
term =
factor[propagate] >>
*( (qi::string("*")[push] >> factor[propagate]) |
(qi::string("/")[push] >> factor[propagate]) );
factor =
(identifier | myDouble_)[push] |
qi::string("(")[push] >> expression[propagate] >> qi::string(")")[push];
identifier = qi::raw [ qi::lexeme[ (qi::alpha | '_') >> *(qi::alnum | '_') ] ];
myDouble_ = qi::raw [ qi::double_ ];
BOOST_SPIRIT_DEBUG_NODES((expression)(term)(factor)(identifier)(myDouble_))
}
qi::rule<It, std::vector<std::string>(), boost::spirit::ascii::space_type> expression;
qi::rule<It, std::vector<std::string>(), boost::spirit::ascii::space_type> factor;
qi::rule<It, std::vector<std::string>(), boost::spirit::ascii::space_type> term;
qi::rule<It, std::string(), boost::spirit::ascii::space_type> identifier;
qi::rule<It, std::string(), boost::spirit::ascii::space_type> myDouble_;
};
int main() {
Tokeniser<> tok;
std::string const input = "x + 89/(y*y)";
auto f = input.begin(), l = input.end();
std::vector<std::string> tokens;
if (phrase_parse(f, l, tok, boost::spirit::ascii::space, tokens)) {
std::cout << "Parsed " << tokens.size() << " tokens:\n";
for (auto& token : tokens)
std::cout << " - '" << token << "'\n";
} else {
std::cout << "Parse failed\n";
}
if (f != l)
std::cout << "Remaining unparsed input: '" << std::string(f,l) << "'\n";
}
#define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
#include <vector>
namespace qi = boost::spirit::qi;
template <typename It = std::string::const_iterator>
struct Tokeniser : qi::grammar <It, std::vector <std::string>()> {
Tokeniser() : Tokeniser::base_type(start)
{
start = qi::skip(boost::spirit::ascii::space) [expression];
expression =
term >>
*( (qi::string("+") >> term) |
(qi::string("-") >> term) );
term =
factor >>
*( (qi::string("*") >> factor) |
(qi::string("/") >> factor) );
factor =
(identifier | myDouble_) |
qi::string("(") >> expression >> qi::string(")");
identifier = qi::raw [ (qi::alpha | '_') >> *(qi::alnum | '_') ];
myDouble_ = qi::raw [ qi::double_ ];
BOOST_SPIRIT_DEBUG_NODES((expression)(term)(factor)(identifier)(myDouble_))
}
qi::rule<It, std::vector<std::string>()> start;
qi::rule<It, std::vector<std::string>(), boost::spirit::ascii::space_type> expression, factor, term;
qi::rule<It, std::string()> identifier, myDouble_;
};
int main() {
Tokeniser<> tok;
std::string const input = "x + 89/(y*y)";
auto f = input.begin(), l = input.end();
std::vector<std::string> tokens;
if (parse(f, l, tok, tokens)) {
std::cout << "Parsed " << tokens.size() << " tokens:\n";
for (auto& token : tokens)
std::cout << " - '" << token << "'\n";
} else {
std::cout << "Parse failed\n";
}
if (f != l)
std::cout << "Remaining unparsed input: '" << std::string(f,l) << "'\n";
}
遗留问题
你有没有想过回溯行为?我认为您需要在您的规则中明智地放置一些qi::hold[]
指令,请参见例如
重大问题:
当你想要的只是令牌时,你为什么要“解析”呢
你将如何处理代币?解析器构建了大量信息,但又一次丢弃了这些信息
简短回答:是的。不,你不应该。我的回答对这里发生的事情有一个更长的解释。
Parsed 9 tokens:
- 'x'
- '+'
- '89'
- '/'
- '('
- 'y'
- '*'
- 'y'
- ')'