Boost :: spirit :: qi, определяющий калькулятор для нулевых значений

Я пытаюсь написать синтаксический анализатор для математических выражений, где именованные переменные являются нулевыми в boost::spirit (версия 1_51_0), к которой я совершенно новичок. Я определяю typedef boost::function<double()> Value и мои правила будут объявлены так: qi::rule<Iterator, Value()> expression, term, others, ...;

Я определяю бинарные операторы на nullaries с помощью этого макроса

#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 связано со следующим сроком. Какой правильный синтаксис для определения такого правила?

4

Решение

Выражение парсера выглядит хорошо.

Что вас смущает, так это создание AST. По-видимому, вы решили использовать для этого Семантические Действия, но ваши усилия слишком поверхностны, чтобы я мог понять, как именно (или даже решить, на каком образце вы основываетесь).

По сути: что вы хотите делать с экземплярами «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
5

Другие решения

Других решений пока нет …

По вопросам рекламы ammmcru@yandex.ru
Adblock
detector