为什么我不能访问语义操作中的值？

Question

我正在尝试编写一个解析器来使用 boost::spirit 创建 AST。作为第一步，我试图将数值包装在 AST 节点中。这是我正在使用的代码：

AST_NodePtr make_AST_NodePtr(const int& i) {
    return std::make_shared<AST_Node>(i);
}

namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
namespace l = qi::labels;

 template<typename Iterator>
    struct test_grammar : qi::grammar<Iterator, AST_NodePtr(), ascii::space_type> {
        test_grammar() : test_grammar::base_type(test) {

            test = qi::int_ [qi::_val = make_AST_NodePtr(qi::_1)];
        }
        qi::rule<Iterator, AST_NodePtr(), ascii::space_type> test;

    };

据我从文档中了解到 q::_1 应该包含 qi::int_ 解析的值，但是上面的代码总是给我一个错误

invalid initialization of reference of type ‘const int&’ from expression of type ‘const _1_type {aka const boost::phoenix::actor<boost::spirit::argument<0> >}

为什么即使 qi::_1 应该保存已解析的值，这仍然不起作用？我还能如何将输入解析为自定义 AST？

Answer 1

您正在语义操作中使用常规函数。

这意味着 在构造函数中 编译器将尝试使用提供的参数调用 make_AST_NodePtr 函数：qi::_1.

Q. Why does this not work even though qi::_1 is supposed to hold the parsed valued?

A. qi::_1 不保持解析值。它表示（是一个占位符）函数调用中的第一个未绑定参数

这/显然/永远行不通。该函数需要一个整数。

那么有什么好处呢？

您需要制作一个"lazy"或"deferred"函数用于语义动作。仅使用预先提供的 Boost Phoenix 仿函数，您可以拼出：

test  = qi::int_ [ qi::_val = px::construct<AST_NodePtr>(px::new_<AST_Node>(qi::_1)) ];

这样就不需要辅助函数了。但结果既丑陋又次优。所以，让我们做得更好！

使用 Phoenix 函数包装器

struct make_shared_f {
    std::shared_ptr<AST_Node> operator()(int v) const {
        return std::make_shared<AST_Node>(v);
    }
};
px::function<make_shared_f> make_shared_;

有了这个定义，你可以将语义动作简化为：

test  = qi::int_ [ qi::_val = make_shared_(qi::_1) ];

实际上，如果将其设为通用，则可以将其重用于多种类型：

template <typename T>
    struct make_shared_f {
        template <typename... Args>
            std::shared_ptr<T> operator()(Args&&... args) const {
                return std::make_shared<T>(std::forward<Args>(args)...);
            }
    };
px::function<make_shared_f<AST_Node> > make_shared_;

演示

这是一个独立的示例，显示了过程中的一些样式修复：

Live On Coliru

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <memory>

struct AST_Node {
    AST_Node(int v) : _value(v) {}
    int value() const { return _value; }
  private:
    int _value;
};

using AST_NodePtr = std::shared_ptr<AST_Node>;

AST_NodePtr make_AST_NodePtr(const int& i) {
    return std::make_shared<AST_Node>(i);
}

namespace qi    = boost::spirit::qi;
namespace px    = boost::phoenix;

template<typename Iterator>
struct test_grammar : qi::grammar<Iterator, AST_NodePtr()> {
    test_grammar() : test_grammar::base_type(start) {
        using boost::spirit::ascii::space;

        start = qi::skip(space) [ test ];

        test  = qi::int_ [ qi::_val = make_shared_(qi::_1) ];
    }
  private:
    struct make_shared_f {
        std::shared_ptr<AST_Node> operator()(int v) const {
            return std::make_shared<AST_Node>(v);
        }
    };
    px::function<make_shared_f> make_shared_;
    //
    qi::rule<Iterator, AST_NodePtr()> start;
    qi::rule<Iterator, AST_NodePtr(), boost::spirit::ascii::space_type> test;
}; 

int main() {
AST_NodePtr parsed;

    std::string const input ("42");
    auto f = input.begin(), l = input.end();
    test_grammar<std::string::const_iterator> g;
    bool ok = qi::parse(f, l, g, parsed);

    if (ok) {
        std::cout << "Parsed: " << (parsed? std::to_string(parsed->value()) : "nullptr") << "\n";
    } else {
        std::cout << "Failed\n";
    }

    if (f!=l)
    {
        std::cout << "Remaining input: '" << std::string(f, l) << "'\n";
    }
}

版画

Parsed: 42

奖励：使用 BOOST_PHOENIX_ADAPT_FUNCTION

的替代方法

如果你愿意，你可以实际使用你的免费功能，并按如下方式使用：

Live On Coliru

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <memory>

struct AST_Node {
    AST_Node(int v) : _value(v) {}
    int value() const { return _value; }
  private:
    int _value;
};

using AST_NodePtr = std::shared_ptr<AST_Node>;

AST_NodePtr make_AST_NodePtr(int i) {
    return std::make_shared<AST_Node>(i);
}

BOOST_PHOENIX_ADAPT_FUNCTION(AST_NodePtr, make_AST_NodePtr_, make_AST_NodePtr, 1)

namespace qi    = boost::spirit::qi;
namespace px    = boost::phoenix;

template<typename Iterator>
struct test_grammar : qi::grammar<Iterator, AST_NodePtr()> {
    test_grammar() : test_grammar::base_type(start) {
        using boost::spirit::ascii::space;

        start = qi::skip(space) [ test                            ] ;
        test  = qi::int_        [ qi::_val = make_AST_NodePtr_(qi::_1) ] ;
    }
  private:
    qi::rule<Iterator, AST_NodePtr()> start;
    qi::rule<Iterator, AST_NodePtr(), boost::spirit::ascii::space_type> test;
}; 

int main() {
AST_NodePtr parsed;

    std::string const input ("42");
    auto f = input.begin(), l = input.end();
    test_grammar<std::string::const_iterator> g;
    bool ok = qi::parse(f, l, g, parsed);

    if (ok) {
        std::cout << "Parsed: " << (parsed? std::to_string(parsed->value()) : "nullptr") << "\n";
    } else {
        std::cout << "Failed\n";
    }

    if (f!=l)
    {
        std::cout << "Remaining input: '" << std::string(f, l) << "'\n";
    }
}

为什么我不能访问语义操作中的值？

Why can I not access the value in a semantic action?

c++

boost-spirit

boost-spirit-qi

使用 Phoenix 函数包装器

演示

奖励：使用 BOOST_PHOENIX_ADAPT_FUNCTION