Boost.Parser: Unerwarteter Typ für Attribut ⇐ C++

[Anonymous]

Ich erstelle derzeit einen Ausdrucksparser in Boost.Parser. Es sollte in der Lage sein,

• Klammern ( ( ... ) ) und abs ( | ... |)
• Unäres Minus
• Potenzen ( x^y)
• (andere arithmetische Operationen, die für die Frage nicht relevant sind) auszuführen.

Hier ist mein Setup Bisher:

Code: Select all

class ExpressionAst { /* ... */ };
class NumberNode : public ExpressionAst { /* ... */ };
class UnaryOpNode : public ExpressionAST { /* ... */ };
class BinaryOpNode : public ExpressionAST { /* ... */ };

bp::rule number = "number";
bp::rule primary = "primary";
bp::rule unary = "unary";
bp::rule power = "power";
bp::rule expression = "expression";

auto make_unary_minus_node = [](auto& ctx) {
auto attr = _attr(ctx);
_val(ctx) = std::make_shared(std::move(attr), UnaryOpNode::Op::Negate);
};

auto make_parentheses_node = [](auto& ctx) { _val(ctx) = _attr(ctx); };

auto make_abs_node = [](auto& ctx) {
auto attr = _attr(ctx);
_val(ctx) = std::make_shared(std::move(attr), UnaryOpNode::Op::Abs);
};

auto const number_def = (-sign >> (hex_literal | octal_literal | binary_literal | decimal_literal) >> -quantifier)[make_number_node];

auto const primary_def = number //
| ('(' >> expression >> ')')[make_parentheses_node] //
| ('|' >> expression >> '|')[make_abs_node];

auto const unary_def = ('-' >> unary)[make_unary_minus_node] //
| primary;

auto const power_def = (unary >> -('^' >> power))[make_power_node];

auto const expression_def = power;

BOOST_PARSER_DEFINE_RULES(number, primary, unary, power, expression);

Jetzt kommt es zur Implementierung meiner semantischen Aktion make_power_node:

Code: Select all

auto make_power_node = [](auto& ctx) {
using attr = std::remove_cvref_t;
static_assert(!std::is_same_v);

// Make compiler happy for now
_val(ctx) = std::make_shared(nullptr, nullptr, BinaryOpNode::Op::Pow);
};

Ich hätte erwartet, dass _attr(ctx) nur ein Tupel ist und es einfach destrukturieren kann. Dies scheint nicht der Fall zu sein. Was mache ich falsch?