时间戳

首页 > 解决方案 > 在 boost::spirit 中正确设置期望失败的跨度

c++ - 在 boost::spirit 中正确设置期望失败的跨度

问题描述

我正在尝试向我的解析器添加错误报告，但我不知道如何针对特定规则正确执行此操作。

有问题的规则匹配形式为mag(12.5)or的函数调用sqrt(5.38)。有一个固定的函数名称列表，每个函数名称的解析方式都与其他的不同（time(4)例如，只接受 int 值）。我的语法生成了一个 AST，其中每个函数都有自己的节点类型（Mag和Sqrt）Time。

我的第一个实现很简单：我支持的每个功能都有一个规则。

fn %= mag | sqrt | time;
mag %= (lit("mag") >> lit('(') > double_ > lit(')'));
sqrt %= (lit("sqrt") >> lit('(') > double_ > lit(')'));
time %= (lit("time") >> lit('(') > int_ > lit(')'));

这可行，但如果输入包含不受支持的函数名称 ( hello(12))，则规则将失败而不会出现错误。我想要的是失败的规则expectation_failure（或类似的），这会说“预期的 mag，sqrt 或时间，得到'你好'”。

下面是我尝试生成错误。它读取任何 ident 后跟一个左括号（使用期望运算符），然后使用谓词 ineps做两件事：根据函数名称生成正确的节点，如果名称未知则失败，从而生成expectation_failure. 问题是 的位置expectation_failure不是我想要的。它产生：

Expected <function parameters>
Got 12)

代替

Expected <mag, sqrt or time>
Got hello

有没有办法控制和的expectation_failure::first值::last？expectation_failure或者，除了我应该使用的方法之外，还有其他方法可以报告错误吗？另外，我不明白为什么我expectation_failure在这种情况下指向“12）”而不仅仅是“12”。

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_function.hpp>
#include <iostream>
#include <string>

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

struct Mag { double val; };
struct Sqrt { double val; };
struct Time { int val; };
using Fn = boost::variant<Mag, Sqrt, Time>;

std::ostream& operator<<(std::ostream& os, const Mag& v) {
  os << "mag(" << v.val << ")";
  return os;
}

std::ostream& operator<<(std::ostream& os, const Sqrt& v) {
  os << "sqrt(" << v.val << ")";
  return os;
}

std::ostream& operator<<(std::ostream& os, const Time& v) {
  os << "time(" << v.val << ")";
  return os;
}


BOOST_FUSION_ADAPT_STRUCT(Mag, (double, val))
BOOST_FUSION_ADAPT_STRUCT(Sqrt, (double, val))
BOOST_FUSION_ADAPT_STRUCT(Time, (int, val))


void makeMag_(Fn& fn, double val) {
  Mag s;
  s.val = val;
  fn.swap(Fn(s));
}

void makeSqrt_(Fn& fn, double val) {
  Sqrt s;
  s.val = val;
  fn.swap(Fn(s));
}

void makeTime_(Fn& fn, int val) {
  Time s;
  s.val = val;
  fn.swap(Fn(s));
}

BOOST_PHOENIX_ADAPT_FUNCTION(void, makeMag, makeMag_, 2)
BOOST_PHOENIX_ADAPT_FUNCTION(void, makeSqrt, makeSqrt_, 2)
BOOST_PHOENIX_ADAPT_FUNCTION(void, makeTime, makeTime_, 2)

template <typename Iterator>
struct FnParser : qi::grammar<Iterator, qi::locals<std::string>, ascii::space_type, Fn()>
{
  FnParser() : FnParser::base_type(fn)
  {
    using qi::double_;
    using qi::int_;
    using qi::_val;
    using qi::_1;
    using qi::_a;
    using qi::_r1;
    using qi::eps;
    using qi::lit;
    using qi::lexeme;
    using qi::alpha;

    ident %= lexeme[+alpha];

    fnParams =
          (eps(_r1 == "mag")  >> double_)  [makeMag(_val, _1)]
        | (eps(_r1 == "sqrt") >> double_)  [makeSqrt(_val, _1)]
        | (eps(_r1 == "time") >> int_)     [makeTime(_val, _1)]
        ;

    fn =  ident        [_a = _1]
        > lit('(')
        > fnParams(_a) [_val = _1]
        > lit(')');

    ident.name("identifier");
    fnParams.name("function parameters");
    fn.name("function");
  }

  qi::rule<Iterator, qi::locals<std::string>, ascii::space_type, Fn()> fn;
  qi::rule<Iterator, ascii::space_type, Fn(std::string)> fnParams;
  qi::rule<Iterator, ascii::space_type, std::string()> ident;
};

int main() {

      using Iter = std::string::const_iterator;
      using boost::spirit::ascii::space;

      FnParser <Iter> parser;

      std::string str;

      while (std::getline(std::cin, str)) {

        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
          break;

        Iter iter = str.begin();
        Iter end = str.end();
        Fn fn;

        try {
          bool r = phrase_parse(iter, end, parser, space, fn);

          if (r && iter == end) {
            std::cout << "Ok\n";
          } else {
            std::string rest(iter, end);
            std::cout << "Failed\n"
                      << "Stopped at \"" << rest << "\"\n";
          }
        } catch(qi::expectation_failure<Iter> e) {
          std::string got(e.first, e.last);
          std::cout << "Expected " << e.what_ << "\n"
                    << "Got " << std::string(e.first, e.last) << "\n";
        }
      }
    }

编辑

我没有给出完整的语法，因此可能缺少一些上下文。除了函数调用，完整的文法还有算术运算符和变量。区分函数调用和变量的唯一方法是之后出现左括号。两者都可以在相同的上下文中使用，我使用有序的替代方案fn | var来优先考虑函数调用。这就是为什么我把期望点放在括号之后，而不是之前。

标签： c++boost-spirit

解决方案

您已经控制了预期失败的位置。

在例如

mag %= (lit("mag") >> lit('(') > double_ > lit(')'));

期望点是> double_。要将其移动到参数列表的开头，请说：

mag %= lit("mag") > (lit('(') >> double_ > lit(')'));

顺便说一句，你可以这样写：

mag = "mag" > ('(' >> double_ >> ')'));

另外，我不明白为什么我的expectation_failure 在这种情况下指向“12）”而不仅仅是“12”。

我认为它只是打印到输入序列的末尾。在输入迭代器 ( ) 的情况下，它可能会打印到输入的最后一部分qi::istream_iterator，但这是猜测。

作为旁注，您可以使用on_error此处记录的更多控制权：https ://www.boost.org/doc/libs/1_67_0/libs/spirit/doc/html/spirit/qi/tutorials/mini_xml___error_handling.html和在编译器示例中。

更新

到编辑

区分函数调用和变量的唯一方法是之后出现左括号。两者都可以在相同的上下文中使用，我使用有序的替代 fn | var 优先考虑函数调用。这就是为什么我把期望点放在括号之后，而不是之前。

你仍然可以拥有它：

mag = "mag" >> &lit('(') > ('(' >> double_ >> ')'));

这使用先行&lit('(')进入分支，然后从期望点开始。因此， no'('​​只是不匹配，但期望点仍然在参数列表中“触发”。

用于否定前瞻断言!lit('(')。（此处和此处的文档）。

其他想法

你说：

区分函数调用和变量的唯一方法是之后出现左括号

这当然取决于您对符号表和语义分析的选择。请参阅这些示例，其中我确实动态地进行了功能检测：

有点远相关：

推荐阅读