在 Qi 中对解析器公开的属性应用操作
Applying operations on parser exposed attributes in Qi
假设我有两个用逗号分隔的双打来解析返回它们的总和。我可能会在 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？
首先是快速回答
why am I getting 1 instead of 3?
您可能会得到 1，因为这是公开的属性。³
但是，由于未定义的行为，您无法对代码进行推理。
你的语义动作
调用 UB：您分配给 a，其生命周期在解析器构造函数结束时结束。那是随机内存损坏
无效：操作 [a+_1] 是一个表达式，它导致一个临时值是 /whatever is at the memory location that used to hold the local variableaat the time of parser construction/ 的总和 和主题解析器公开的属性 (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.
是的，但是使用精神
我明白了:)
嗯，首先，我们要意识到暴露的属性是双精度数，而不是列表。
下一步是意识到列表中的各个元素并不重要。我们可以将结果初始化为 0 并用它来累加元素¹，例如：
#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
进阶的东西：
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
可以通过处理该异常类型来改进：
版画
'1,,' -> Expecting <eoi> at ',,'
How about accepting spaces?
只需使用 phrase_parse，它允许船长在 lexemes.²:
之外
bool ok = phrase_parse(source.begin(), source.end(), double_ [ px::ref(result) += _1 ] % ',' > eoi, blank);
现在，原语之间的所有 blank 都被忽略了：
test(" 1, 2 ");
版画
' 1, 2 ' -> 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 ] % ','
;
}
打印与之前相同的结果
¹ 请记住，求和是一个有趣的主题，http://www.partow.net/programming/sumtk/index.html
² 原始解析器是隐含的词素，lexeme[] 指令禁止跳过，没有船长声明的规则是隐含的词素：Boost spirit skipper issues
³ PS。这里有一个微妙之处。如果您不写 %= 而只是写 =，那么该值将是不确定的：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
假设我有两个用逗号分隔的双打来解析返回它们的总和。我可能会在 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？
首先是快速回答
why am I getting 1 instead of 3?
您可能会得到 1，因为这是公开的属性。³
但是，由于未定义的行为，您无法对代码进行推理。
你的语义动作
调用 UB：您分配给
a，其生命周期在解析器构造函数结束时结束。那是随机内存损坏无效：操作
[a+_1]是一个表达式，它导致一个临时值是/whatever is at the memory location that used to hold the local variableaat the time of parser construction/的总和 和主题解析器公开的属性 (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.
是的，但是使用精神
我明白了:)
嗯，首先，我们要意识到暴露的属性是双精度数，而不是列表。
下一步是意识到列表中的各个元素并不重要。我们可以将结果初始化为 0 并用它来累加元素¹，例如：
#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
进阶的东西：
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可以通过处理该异常类型来改进：
版画
'1,,' -> Expecting <eoi> at ',,'How about accepting spaces?
只需使用
之外phrase_parse，它允许船长在lexemes.²:bool ok = phrase_parse(source.begin(), source.end(), double_ [ px::ref(result) += _1 ] % ',' > eoi, blank);现在，原语之间的所有
blank都被忽略了：test(" 1, 2 ");版画
' 1, 2 ' -> 3How 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 ] % ',' ; }打印与之前相同的结果
¹ 请记住，求和是一个有趣的主题，http://www.partow.net/programming/sumtk/index.html
² 原始解析器是隐含的词素，lexeme[] 指令禁止跳过，没有船长声明的规则是隐含的词素：Boost spirit skipper issues
³ PS。这里有一个微妙之处。如果您不写 %= 而只是写 =，那么该值将是不确定的：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