提升精神解析器不编译
Boost spirit parser not compiling
本文关键字：编译 更新时间：2023-10-16
我试图用boost：：spirit编写一个简单的表达式解析器。我从计算器示例开始（参见：http://www.boost.org/doc/libs/1_41_0/libs/spirit/example/qi/calc2_ast.cpp），并尝试添加一个表示对变量引用的"ref"规则。这是我的代码：
#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/variant/recursive_variant.hpp>
#include <boost/variant/apply_visitor.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_function.hpp>
#include <iostream>
#include <vector>
#include <string>
namespace client{
namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
///////////////////////////////////////////////////////////////////////////
// Our AST
///////////////////////////////////////////////////////////////////////////
struct binary_op;
struct unary_op;
struct ref {
std::string name;
ref(const std::string& name) : name(name){}
};
struct nil {};
struct expression_ast
{
typedef
boost::variant<
nil // can't happen!
, unsigned int
, ref
, boost::recursive_wrapper<expression_ast>
, boost::recursive_wrapper<binary_op>
, boost::recursive_wrapper<unary_op>
>
type;
expression_ast()
: expr(nil()) {}
template <typename Expr>
expression_ast(Expr const& expr)
: expr(expr) {}
expression_ast& operator+=(expression_ast const& rhs);
expression_ast& operator-=(expression_ast const& rhs);
expression_ast& operator*=(expression_ast const& rhs);
expression_ast& operator/=(expression_ast const& rhs);
type expr;
};
struct binary_op
{
binary_op(
char op
, expression_ast const& left
, expression_ast const& right)
: op(op), left(left), right(right) {}
char op;
expression_ast left;
expression_ast right;
};
struct unary_op
{
unary_op(
char op
, expression_ast const& subject)
: op(op), subject(subject) {}
char op;
expression_ast subject;
};
expression_ast& expression_ast::operator+=(expression_ast const& rhs)
{
expr = binary_op('+', expr, rhs);
return *this;
}
expression_ast& expression_ast::operator-=(expression_ast const& rhs)
{
expr = binary_op('-', expr, rhs);
return *this;
}
expression_ast& expression_ast::operator*=(expression_ast const& rhs)
{
expr = binary_op('*', expr, rhs);
return *this;
}
expression_ast& expression_ast::operator/=(expression_ast const& rhs)
{
expr = binary_op('/', expr, rhs);
return *this;
}
// We should be using expression_ast::operator-. There's a bug
// in phoenix type deduction mechanism that prevents us from
// doing so. Phoenix will be switching to BOOST_TYPEOF. In the
// meantime, we will use a phoenix::function below:
struct negate_expr
{
template <typename T>
struct result { typedef T type; };
expression_ast operator()(expression_ast const& expr) const
{
return expression_ast(unary_op('-', expr));
}
};
struct ref_maker
{
template <typename T>
struct result { typedef T type; };
ref operator()(std::string const& expr) const
{
return expr;
}
};
boost::phoenix::function<negate_expr> neg;
boost::phoenix::function<ref_maker> make_ref;
///////////////////////////////////////////////////////////////////////////
// Walk the tree
///////////////////////////////////////////////////////////////////////////
struct ast_print
{
typedef void result_type;
void operator()(qi::info::nil) const {
}
void operator()(int n) const {
std::cout << n;
}
void operator()(expression_ast const& ast) const {
boost::apply_visitor(*this, ast.expr);
}
void operator()(binary_op const& expr) const {
std::cout << "op:" << expr.op << "(";
boost::apply_visitor(*this, expr.left.expr);
std::cout << ", ";
boost::apply_visitor(*this, expr.right.expr);
std::cout << ')';
}
void operator()(unary_op const& expr) const {
std::cout << "op:" << expr.op << "(";
boost::apply_visitor(*this, expr.subject.expr);
std::cout << ')';
}
void operator()(ref const& expr) const {
std::cout << "ref:" << expr.name ;
}
};
///////////////////////////////////////////////////////////////////////////
// Our calculator grammar
///////////////////////////////////////////////////////////////////////////
template <typename Iterator>
struct calculator : qi::grammar<Iterator, expression_ast(), ascii::space_type>
{
calculator() : calculator::base_type(expression)
{
using qi::_val;
using qi::_1;
using qi::uint_;
using qi::lit;
using ascii::alnum;
identifier = (alnum [_val += _1]);
expression =
term [_val = _1]
>> *( ('+' >> term [_val += _1])
| ('-' >> term [_val -= _1])
)
;
term =
factor [_val = _1]
>> *( ('*' >> factor [_val *= _1])
| ('/' >> factor [_val /= _1])
)
;
factor =
uint_ [_val = _1]
| identifier [_val = make_ref(_1)]
| '(' >> expression [_val = _1] >> ')'
| ('-' >> factor [_val = neg(_1)])
| ('+' >> factor [_val = _1])
;
}
qi::rule<Iterator, std::string(), ascii::space_type> identifier;
qi::rule<Iterator, expression_ast(), ascii::space_type> expression, term, factor;
};
}
///////////////////////////////////////////////////////////////////////////////
// Main program
///////////////////////////////////////////////////////////////////////////////
int
main()
{
std::cout << "/////////////////////////////////////////////////////////nn";
std::cout << "Expression parser...nn";
std::cout << "/////////////////////////////////////////////////////////nn";
std::cout << "Type an expression...or [q or Q] to quitnn";
using client::ascii::space;
using client::expression_ast;
using client::ast_print;
typedef std::string::const_iterator iterator_type;
typedef client::calculator<iterator_type> calculator;
calculator calc; // Our grammar
std::string str;
while (std::getline(std::cin, str))
{
if (str.empty() || str[0] == 'q' || str[0] == 'Q')
break;
std::string::const_iterator iter = str.begin();
std::string::const_iterator end = str.end();
expression_ast ast;
ast_print printer;
bool r = phrase_parse(iter, end, calc, space, ast);
if (r && iter == end)
{
std::cout << "-------------------------n";
std::cout << "Parsing succeededn";
printer(ast);
std::cout << "n-------------------------n";
}
else
{
std::string rest(iter, end);
std::cout << "-------------------------n";
std::cout << "Parsing failedn";
std::cout << "stopped at: ": " << rest << ""n";
std::cout << "-------------------------n";
}
}
std::cout << "Bye... :-) nn";
return 0;
}
我对示例所做的唯一更改如下：
- 在变体中添加
ref结构和条目。 - 添加一个
identifier规则，该规则将单个变量名称读取为string - 创建一个函子和 phoenix 函数
make_ref，用于从string创建ref - 向
factor规则添加一个identifier选项，该选项调用make_ref将identifierstring转换为ref。
代码不起作用。始终存在以下类型错误：
/usr/include/boost/spirit/home/phoenix/core/detail/function_eval.hpp:135:69: error: could not convert ‘bench::expr::ref_maker::operator()(const string&) const((*(const string*)boost::phoenix::detail::help_rvalue_deduction<std::basic_string<char> >((* &(& _0)->boost::spirit::argument<N>::eval<boost::phoenix::basic_environment<boost::fusion::vector1<std::basic_string<char>&>, boost::spirit::context<boost::fusion::cons<bench::expr::expression_ast&, boost::fusion::nil>, boost::fusion::vector0<> >, bool, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_, boost::fusion::void_> >((* & env))))))’ from ‘bench::expr::ref’ to ‘std::basic_string<char>’
看来凤凰是想让make_ref还string而不是ref，但这不是我想要的。我在这里做错了什么？
ref_maker的结果总是ref，与输入参数不同。来得及
struct ref_maker
{
template <typename T>
struct result { typedef ref type; }; // <-- here.
ref operator()(std::string const& expr) const
{
return expr;
}
};
此外，将 main 中的 bench::expr:: 替换为 client:: ，否则会收到命名空间bench::expr不存在的错误。
相关文章：
- 二叉排序树无法编译
- 编译时未启用intel oneApi CUDA支持
- 在VS代码中交叉编译Windows与Linux上的MinGW的SDL程序
- 编译包含字符串的代码时遇到问题
- 告诉一个 const char 数组，除了编译时 C 样式的字符串外，它不以 ' ' 结尾
- 如何在linux终端中同时编译和运行c++代码
- 在Linux for Windows上编译C++代码时出错
- 为什么在没有显式默认构造函数的情况下，将另一个结构封装在联合中作为成员的结构不能编译
- 在编译C++代码(具有dlib和opencv）到WASM时面临问题
- 无法编译 rtmidi 测试 cmidiin.cpp 文件， 非法指令
- 在VS2010-VS2015下编译时，如何使用decltype作为较大类型表达式的LHS
- 如何使用CMake编译.proto文件来生成.grpcp.pb.cc和.grpc.pb.h文件
- 编译C++时未定义的引用
- 使用简单类型列表实现的指数编译时间.为什么
- 编译标准库类型
- 用MacOS Mojave编译C++:致命错误:mpi.h:没有这样的文件或目录
- 为什么即使使用-cudart-static进行编译，库用户仍然需要链接到cuda运行时
- 是否可以在编译时初始化数组，以便在运行时不会花费时间？
- std::is_base_of表示ctor编译错误
- 在已经使用Git的情况下减少编译时间
