c++ - 在 Qi 中对解析器公开的属性应用操作

Question

假设我有两个用逗号分隔的 double 来解析返回它们的总和。在 Haskell 中我可能会这样做:

import Data.Attoparsec.Text
import Data.Text (pack)
dblParse = (\a -> fst a + snd a) <$> ((,) <$> double <* char ',' <*> double)
parseOnly dblParse $ pack "1,2"

parseOnly语句将产生 (Right 3)::Either String Double - 其中 Either 是 Haskell 经常处理错误的方式。

您可以大致了解这是如何工作的 - (,) <$> double <*> double产生 Parser (Double,Double) , 并申请 (\a -> fst a + snd a)使它成为 Parser Double .

我正在尝试在 Qi 中做同样的事情，但是当我期望返回 3 时，我实际上返回了 1:

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

namespace phx = boost::phoenix;

struct cat
{
    double q;
};

BOOST_FUSION_ADAPT_STRUCT(cat, q)
BOOST_FUSION_ADAPT_STRUCT(cat, q)
template <typename Iterator>
struct cat_parser : qi::grammar<Iterator, cat()>
{
    cat_parser() : cat_parser::base_type(start)
    {
        using qi::int_;
        using qi::double_;
        using qi::repeat;
        using qi::eoi;
        using qi::_1;
        double a;
        start %= double_[phx::ref(a) =_1] >> ',' >> double_[a + _1];
    }
    qi::rule<Iterator, cat()> start;
};

int main()
    {

        std::string wat("1,2");
        cat_parser<std::string::const_iterator> f;
        cat example;
        std::string::const_iterator st = wat.begin();
        std::string::const_iterator en = wat.end();
        std::cout << parse(st, en, f, example) << std::endl;
        std::cout << example.q << std::endl;
        return 0;
}

我的问题有两个:这是使用 Spirit 执行此操作的惯用方法吗？为什么我得到 1 而不是 3？

Answer 1

首先快速回答

why am I getting 1 instead of 3?

您可能会得到 1，因为这是公开的属性。³

但是，由于未定义的行为，您无法对您的代码进行推理。

你的语义 Action

• 调用 UB:您分配给 a，其生命周期在解析器构造函数结束时结束。那是随机内存损坏

• 无效:操作 [a+_1] 是一个表达式，它产生一个临时值，它是 /内存位置的任何内容的总和用于保存局部变量a在解析器构造时/ 和主题解析器公开的属性 (double_)。在这种情况下，它将是“?+2.0”，但这根本不重要，因为没有对结果进行任何处理:它只是被丢弃。

正常答案

将要求设为公正:

Say I had two doubles separated by a comma to parse returning their sum

这是我们的做法:

double parseDoublesAndSum(std::istream& is) {
    double a, b; char comma;
    if (is >> a >> comma && comma == ',' && is >> b)
        return a + b;

    is.setstate(std::ios::failbit);
    return 0;
}

查看 Live On Coliru 。

是的，但是使用精神

我明白了:)

好吧，首先，我们会意识到暴露的属性是一个 double ，而不是列表。

下一步是意识到列表中的各个元素并不重要。我们可以将结果初始化为 0 并用它来累加元素¹，例如:

Live On Coliru

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

double parseDoublesAndSum(std::string const& source) {
    double result = 0;

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

        bool ok = parse(source.begin(), source.end(), double_ [ px::ref(result) += _1 ] % ',');
        if (!ok)
            throw std::invalid_argument("source: expect comma delimited list of doubles");
    }

    return result;
}

void test(std::string input) {
    try {
        std::cout << "'" << input << "' -> " << parseDoublesAndSum(input) << "\n";
    } catch (std::exception const& e) {
        std::cout << "'" << input << "' -> " << e.what() << "\n";
    }
}
int main() {
    test("1,2");
    test("1,2,3");
    test("1,2,3");
    test("1,2,inf,4");
    test("1,2,-inf,4,5,+inf");
    test("1,2,-NaN");
    test("1,,");
    test("1");
    test("aaa,1");
}

打印

'1,2' -> 3
'1,2,3' -> 6
'1,2,3' -> 6
'1,2,inf,4' -> inf
'1,2,-inf,4,5,+inf' -> -nan
'1,2,-NaN' -> -nan
'1,,' -> 1
'1' -> 1
'aaa,1' -> 'aaa,1' -> source: expect comma delimited list of doubles

进阶的东西:

1. woah, "1,," shouldn't have parsed!

   它没有 :) 我们制定了解析器，不希望消耗全部输入，修复:追加 >> eoi:

   bool ok = parse(source.begin(), source.end(), double_ [ px::ref(result) += _1 ] % ',' >> eoi);
   

   现在打印相关的测试用例

   '1,,' -> '1,,' -> source: expect comma delimited list of doubles
   

   如果我们希望诊断程序提及预期输入结束 (eoi) 怎么办？制作 an expectation point > eoi:

   bool ok = parse(source.begin(), source.end(), double_ [ px::ref(result) += _1 ] % ',' > eoi);
   

   现在打印

   '1,,' -> '1,,' -> boost::spirit::qi::expectation_failure
   

   可以通过处理该异常类型来改进:

   Live On Coliru

   打印

   '1,,' -> Expecting <eoi> at ',,'
   

2. How about accepting spaces?

   只需使用 phrase_parse，它允许 lexemes.² 之外的船长:

   bool ok = phrase_parse(source.begin(), source.end(), double_ [ px::ref(result) += _1 ] % ',' > eoi, blank);
   

   现在，原语之间的所有空白都被忽略了:

   test("   1, 2   ");
   

   打印

   '   1, 2   ' -> 3
   

3. How to package it up as rule?

   正如我提到的，意识到您可以使用规则的公开属性作为累加器寄存器:

   namespace Parsers {
       static const qi::rule<iterator, double(), qi::blank_type> product
           = qi::eps [ qi::_val = 0 ] // initialize
           >> qi::double_ [ qi::_val += qi::_1 ] % ','
           ;
   }
   

   Live On Coliru

   打印和之前一样的结果

---

¹ 请记住求和是一个有趣的主题，http://www.partow.net/programming/sumtk/index.html

² 原始解析器是隐含的词素，lexeme[] 指令禁止跳过，并且在没有船长的情况下声明的规则是隐含的词素:Boost spirit skipper issues

³ 附言。这里有一个微妙之处。如果您不写 %= 而只是写 =，那么该值将是不确定的:http://www.boost.org/doc/libs/1_65_1/libs/spirit/doc/html/spirit/qi/reference/nonterminal/rule.html#spirit.qi.reference.nonterminal.rule.expression_semantics