Question

我在玩基于Boost.Spirit.Qi的解析。有一个像calc_utree这样的例子，我试图扩展用作语义动作的东西。

将单独的赋值作为语义动作重用相同的方法是微不足道的，例如

        term =
            factor [_val = _1]

就像在字面上的例子。但是，当我尝试将两者都传递到规则定义外部的函数（方法），或者甚至将其写为lambda时，例如

        term =
            factor [([&] {_val = _1; })]

它会在该位置导致静默错误分配：_val保持不变（编译器没有任何错误或警告）。如果我把它改成像

那样的话也一样

        term =
            factor [do_term_factor(_val, _1)]
<...>
template <typename D, typename S>
D& do_term_factor(D& d, S& s) {
    d = s;
}

似乎我与Qi和Phoenix陷入了主要的误解。问题是（主要是同一个问题的不同形式）：

具有Phoenix变量的特定内容，它们在C ++ lambdas中不起作用？
如何使用这种外部动作调用？

或者，如果没有_val，Phoenix如何实现？ Spirit文档在这方面似乎很模糊。

环境细节：Boost 1.58.0，gcc 5.4.0或clang 4.0（所有Ubuntu 16.04）。

Answer 1

@llonesmiz提供的链接非常好。

简而言之：你需要让函数适应懒惰的演员。 _val = _1也是这样，但是＆＃34;神奇地＆＃34;使用表达模板生成。

对于＆＃34;常规＆＃34;你有健忘者

升压::凤::功能
升压::凤::结合
BOOST_FUNCTION_ADAPT _ *

这是一个小游行

<强> Live On Coliru

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

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

//////////////////// bindables
struct GenericDoubler {
    template <typename T>
    auto operator()(T const& v) const { return v * 2; }
};
static const px::function<GenericDoubler> s_genericDoubler;

template <typename T>
T freeGenericDouble(T const& v) { return v * 2; }

BOOST_PHOENIX_ADAPT_FUNCTION(int, genericDouble_, freeGenericDouble, 1)

/////////////////// raw actors
int main() {
    using It = std::string::const_iterator;
    std::string const input = "42";

    using namespace qi::labels;

    for (auto rule : std::vector<qi::rule<It, int()> > { 
                // binds
                qi::int_ [ _val = 2*_1 ],
                qi::int_ [ _val = px::bind([](int i) { return 2*i; }, _1) ],
                qi::int_ [ _val = px::bind(GenericDoubler(), _1) ],
                qi::int_ [ _val = px::bind(&freeGenericDouble<int>, _1) ],
                qi::int_ [ _val = genericDouble_(_1) ],
                qi::int_ [ _val = s_genericDoubler(_1) ],
                // actors
                qi::int_ [ ([](int const& /*attribute*/, auto& /*context*/, bool& pass) { 
                        // context is like boost::spirit::context<boost::fusion::cons<int&, boost::fusion::nil_>, boost::fusion::vector<> >
                        pass = false;
                    }) ],
                qi::int_ [ ([](int& attribute, auto& context, bool& pass) { 
                        int& exposed = boost::fusion::at_c<0>(context.attributes);
                        exposed = 2*attribute;
                        pass = true;
                    }) ],
            }) 
    {
        It f = begin(input), l = end(input);
        int data = 99;
        if (parse(f, l, rule, data))
            std::cout << "Parsed: " << data << " ";
        else
            std::cout << "Parse failed at '" << std::string(f,l) << "' ";

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

打印

Parsed: 84 
Parsed: 84 
Parsed: 84 
Parsed: 84 
Parsed: 84 
Parsed: 84 
Parse failed at '42' Remaining: '42'
Parsed: 84

使用lambdas或外部函数作为spirit.qi语义行为

1 个答案: