Boost::spirit::qi定义了一个用于计数的计算器

Boost::spirit::qi defining a calculator for nullaries

本文关键字：用于 一个 计算器 qi spirit 定义 Boost      更新时间：2023-10-16

我正试图为数学表达式写一个解析器，其中命名的变量是boost::spirit(版本1_51_0)中的nullaries，我是全新的。我定义了typedef boost::function<double()> Value，我的规则将这样声明:qi::rule<Iterator, Value()> expression, term, others, ...;

我用这个宏

在零点上定义二元操作符
#define BINARY_FUNCTOR(name, op)                        
struct name                                             
{                                                       
  name(Value x, Value y): x_(x), y_(y) {}               
  double operator()() { return x_() op y_(); }          
  Value x_, y_;                                         
};

，有ADD、SUB等。从我看到的例子来看，我希望规则是这样定义的:

expression = term
             >> *( (lit('+') >> term[ADD(_val, _1)])
                 | (lit('-') >> term[SUB(_val, _1)])
                 );

，但这似乎不是正确的语法，因为我得到一个错误

boost/spirit/home/support/action_dispatch.hpp:162: error: no match for call to ‘(const<unnamed>::SUB) (boost::function<double ()()>&, boost::spirit::context<boost::fusion::cons<boost::function<double ()()>&, boost::fusion::nil>, boost::fusion::vector0<void> >&, bool&)’
SRParser.cpp:38: note: candidates are: double<unnamed>::SUB::operator()()

在我看来像_1并不完全是我所期望的，即与下一项相关的Value。定义这样一个规则的正确语法是什么?

解析器表达式看起来没有问题。

你所困惑的是在构造AST。显然，你已经决定使用Semantic Actions来做这件事，但是你的努力对我来说太粗略了，我看不出你是如何做的(甚至决定你基于什么样本)。

本质上:你想做什么与'ADD'/'SUB'的实例，你似乎神奇地将"将"到你的规则?

现在，您只需直接使用实例作为语义操作。这将导致所示的错误消息，它直接告诉您，实例作为语义操作无效。

我假设您真的想使用Phoenix赋值将二进制操作赋值给公开的属性。这看起来像:

expression = term
     >> *( (lit('+') >> term[ _val = phx::construct<ADD>(_val, _1)])
         | (lit('-') >> term[ _val = phx::construct<SUB>(_val, _1)])
         );

您将看到这与传统的表达式语法更加匹配。

为了好玩，我根据您的Value类型改编了一个完整的表达式解析器，并创建了这个工作演示:http://liveworkspace.org/code/3kgPJR$0

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/phoenix.hpp>
namespace qi    = boost::spirit::qi;
namespace karma = boost::spirit::karma;
namespace phx   = boost::phoenix;
typedef std::function<double()> Value;
#define BINARY_FUNCTOR(name, op)                        
struct name                                             
{                                                       
  name(Value x, Value y): x_(x), y_(y) {}               
  double operator()() { return x_() op y_(); }          
  Value x_, y_;                                         
}; 
BINARY_FUNCTOR(ADD, +)
BINARY_FUNCTOR(SUB, -)
BINARY_FUNCTOR(MUL, *)
BINARY_FUNCTOR(DIV, /)
struct LIT
{
  LIT(double x): x_(x) {}
  double operator()() { return x_; }
  double x_;
}; 
struct NEG
{
  NEG(Value x): x_(x) {}
  double operator()() { return -x_(); }
  Value x_;
}; 

template <typename It, typename Skipper = qi::space_type>
    struct parser : qi::grammar<It, Value(), Skipper>
{
    parser() : parser::base_type(expression)
    {
        using namespace qi;
        expression =
            term                    [_val = _1]
            >> *( ('+' >> term  [_val = phx::construct<ADD>(_val, _1)])
                | ('-' >> term  [_val = phx::construct<SUB>(_val, _1)])
                );
        term =
            factor                [_val = _1]
            >> *( ('*' >> factor  [_val = phx::construct<MUL>(_val, _1)])
                | ('/' >> factor  [_val = phx::construct<DIV>(_val, _1)])
                );
        factor =
            double_               [_val = phx::construct<LIT>(_1)]
            |   '(' >> expression [_val = _1] >> ')'
            |   ('-' >> factor    [_val = phx::construct<NEG>(_1)])
            |   ('+' >> factor    [_val = _1]);
        BOOST_SPIRIT_DEBUG_NODE(expression);
        BOOST_SPIRIT_DEBUG_NODE(term);
        BOOST_SPIRIT_DEBUG_NODE(factor);
    }
  private:
    qi::rule<It, Value(), Skipper> expression, term, factor;
};
Value doParse(const std::string& input)
{
    typedef std::string::const_iterator It;
    parser<It, qi::space_type> p;
    Value eval;
    auto f(begin(input)), l(end(input));
    if (!qi::phrase_parse(f,l,p,qi::space,eval))
        std::cerr << "parse failed: '" << std::string(f,l) << "'n";
    if (f!=l) 
        std::cerr << "trailing unparsed: '" << std::string(f,l) << "'n";
    return eval;
}
int main()
{
    auto area = doParse("2 * (3.1415927 * (10*10))");
    std::cout << "Area of a circle r=10: " << area() << "n";
}

输出

Area of a circle r=10: 628.319
相关文章：