好吧,我本打算写下你的问题有什么问题,但我却去证明自己,做你想要的东西并不难。
几个要点:
- 我稍微修改、重命名和扩展了你的 ast,使其工作并实际显示一些东西。
-
由于某种原因,精神规则会复制属性(我认为这是一个错误),所以我解决了这个问题unique_ptr
具有特征。(1.70 中修复)
- 我不确定是否
x3::omit
那里实际上是必需的(您可以删除除最后一个之外的所有内容,它将编译),但看起来这是 Spirit 中的另一个错误。
-
make_node
看起来不可靠,并且可能会以令人惊讶的方式崩溃,如果您愿意,您可以将其拆分为单独的一元/二元节点创建者。
- 在某些时候,您会希望使用有状态分配器来创建 ast 节点,通过将分配器注入解析器上下文应该非常简单。我把它留给你作为练习。
解析器:
#include <boost/spirit/home/x3.hpp>
#include <memory>
#include <iostream>
namespace ast
{
class expression
{
protected:
expression() = default;
public:
virtual ~expression() = default;
expression(expression&& other) = delete;
expression& operator=(expression&& other) = delete;
virtual void print(std::ostream&) const = 0;
friend std::ostream& operator<<(std::ostream& os, expression const& node)
{
node.print(os);
return os;
}
};
class operand : public expression
{
double value_;
public:
constexpr operand(double value) : value_{value} {}
void print(std::ostream& os) const override { os << value_; }
};
class op_bin : public expression
{
protected:
std::unique_ptr<expression> left_, right_;
public:
op_bin(std::unique_ptr<expression> left, std::unique_ptr<expression> right)
: left_{ std::move(left) }, right_{ std::move(right) }
{}
op_bin(expression * left, expression * right)
: left_{ left }, right_{ right }
{}
};
class plus : public op_bin
{
public:
using op_bin::op_bin;
void print(std::ostream& os) const override
{ os << '(' << *left_ << " + " << *right_ << ')'; }
};
class minus : public op_bin
{
public:
using op_bin::op_bin;
void print(std::ostream& os) const override
{ os << '(' << *left_ << " - " << *right_ << ')'; }
};
class mul : public op_bin
{
public:
using op_bin::op_bin;
void print(std::ostream& os) const override
{ os << '(' << *left_ << " * " << *right_ << ')'; }
};
class div : public op_bin
{
public:
using op_bin::op_bin;
void print(std::ostream& os) const override
{ os << '(' << *left_ << " / " << *right_ << ')'; }
};
} // namespace ast
namespace grammar
{
namespace x3 = boost::spirit::x3;
template <typename T>
struct make_node_
{
template <typename Context>
void operator()(Context const& ctx) const
{
if constexpr (std::is_convertible_v<decltype(x3::_attr(ctx)), T>) {
x3::_val(ctx) = std::make_unique<T>(std::move(x3::_attr(ctx)));
}
else {
x3::_val(ctx) = std::make_unique<T>(std::move(x3::_val(ctx)), std::move(x3::_attr(ctx)));
}
}
};
template <typename T>
constexpr make_node_<T> make_node{};
using x3::double_;
using x3::char_;
x3::rule<class expression_r, std::unique_ptr<ast::expression>, true> const expression;
x3::rule<class prec1_r, std::unique_ptr<ast::expression>, true> const prec1;
x3::rule<class prec0_r, std::unique_ptr<ast::expression>, true> const prec0;
auto const expression_def =
prec1
>> *( x3::omit[('+' > prec1)[make_node<ast::plus>]]
| x3::omit[('-' > prec1)[make_node<ast::minus>]]
)
;
auto const prec1_def =
prec0
>> *( x3::omit[('*' > prec0)[make_node<ast::mul>]]
| x3::omit[('/' > prec0)[make_node<ast::div>]]
)
;
auto const prec0_def =
x3::omit[double_[make_node<ast::operand>]]
| '(' > expression > ')'
;
BOOST_SPIRIT_DEFINE(
expression
, prec1
, prec0
);
} // namespace grammar
#if BOOST_VERSION < 107000
namespace boost::spirit::x3::traits {
template <typename Attribute>
struct make_attribute<std::unique_ptr<Attribute>, std::unique_ptr<Attribute>>
: make_attribute_base<std::unique_ptr<Attribute>>
{
typedef std::unique_ptr<Attribute>& type;
typedef std::unique_ptr<Attribute>& value_type;
};
} // namespace boost::spirit::x3::traits
#endif
int main()
{
namespace x3 = boost::spirit::x3;
std::string s = "1 + 2 * (3 - 4) / 5";
std::unique_ptr<ast::expression> expr;
if (auto iter = s.cbegin(); !phrase_parse(iter, s.cend(), grammar::expression, x3::space, expr)) {
std::cout << "parsing failed";
}
else {
if (iter != s.cend())
std::cout << "partially parsed\n";
std::cout << *expr << '\n';
}
}
Output:
(1 + ((2 * (3 - 4)) / 5))