用于解析 header 列的增强精神语法
boost spirit grammar for parsing header columns
我想解析文本文件的 header 列。列名应该允许被引用和字母的任何大小写。目前我正在使用以下语法：
#include <string>
#include <iostream>
#include <boost/spirit/include/qi.hpp>
namespace qi = boost::spirit::qi;
template <typename Iterator, typename Skipper>
struct Grammar : qi::grammar<Iterator, void(), Skipper>
{
static constexpr char colsep = '|';
Grammar() : Grammar::base_type(header)
{
using namespace qi;
using ascii::char_;
#define COL(name) (no_case[name] | ('"' >> no_case[name] >> '"'))
header = (COL("columna") | COL("column_a")) >> colsep >>
(COL("columnb") | COL("column_b")) >> colsep >>
(COL("columnc") | COL("column_c")) >> eol >> eoi;
#undef COL
}
qi::rule<Iterator, void(), Skipper> header;
};
int main()
{
const std::string s{"columnA|column_B|column_c\n"};
auto begin(std::begin(s)), end(std::end(s));
Grammar<std::string::const_iterator, qi::blank_type> p;
bool ok = qi::phrase_parse(begin, end, p, qi::blank);
if (ok && begin == end)
std::cout << "Header ok" << std::endl;
else if (ok && begin != end)
std::cout << "Remaining unparsed: '" << std::string(begin, end) << "'" << std::endl;
else
std::cout << "Parse failed" << std::endl;
return 0;
}
不使用宏是否可行？此外，我想完全忽略任何下划线。这可以通过自定义船长来实现吗？最后如果能这样写就完美了：
header = col("columna") >> colsep >> col("columnb") >> colsep >> column("columnc") >> eol >> eoi;
其中 col 是适当的语法或规则。
@sehe how can I fix this grammar to support "\"Column_A\"" as well? 6 hours ago
此时您可能已经意识到这里发生了两件不同的事情。
单独关注
一方面，您有一个 语法（允许 | 分隔的列，如 columna 或 "Column_A"）。
另一方面，您有语义分析（检查解析的内容是否符合特定条件的阶段）。
让你的生活变得艰难的是试图将两者混为一谈。现在，请不要误会我的意思，在（非常罕见的）情况下，绝对需要将这些职责融合在一起——但我认为这始终是一种优化。如果你需要它，Spirit 不是你的菜，你更有可能得到手写解析器的服务。
正在解析
所以让我们brain-dead简单了解一下语法：
static auto headers = (quoted|bare) % '|' > (eol|eoi);
bare 和 quoted 规则与以前几乎相同：
static auto quoted = lexeme['"' >> *('\' >> char_ | "\"\"" >> attr('"') | ~char_('"')) >> '"'];
static auto bare = *(graph - '|');
如您所见，这将隐含地处理引用和转义以及跳过词位外的空格。如果简单地应用，它将产生一个干净的列名列表：
std::string const s = "\"columnA\"|column_B| column_c \n";
std::vector<std::string> headers;
bool ok = phrase_parse(begin(s), end(s), Grammar::headers, x3::blank, headers);
std::cout << "Parse " << (ok?"ok":"invalid") << std::endl;
if (ok) for(auto& col : headers) {
std::cout << std::quoted(col) << "\n";
}
Parse ok
"columnA"
"column_B"
"column_c"
间奏曲：编码风格
让我们构造我们的代码以反映关注点分离。我们的解析代码可能使用 X3，但我们的验证代码不需要在同一个翻译单元（cpp 文件）中。
有一个 header 定义一些基本类型：
#include <string>
#include <vector>
using Header = std::string;
using Headers = std::vector<Header>;
定义我们要对它们执行的操作：
Headers parse_headers(std::string const& input);
bool header_match(Header const& actual, Header const& expected);
bool headers_match(Headers const& actual, Headers const& expected);
现在，main 可以重写为：
auto headers = parse_headers("\"columnA\"|column_B| column_c \n");
for(auto& col : headers) {
std::cout << std::quoted(col) << "\n";
}
bool valid = headers_match(headers, {"columna","columnb","columnc"});
std::cout << "Validation " << (valid?"passed":"failed") << "\n";
例如一个 parse_headers.cpp 可以包含：
#include <boost/spirit/home/x3.hpp>
namespace x3 = boost::spirit::x3;
namespace Grammar {
using namespace x3;
static auto quoted = lexeme['"' >> *('\' >> char_ | "\"\"" >> attr('"') | ~char_('"')) >> '"'];
static auto bare = *(graph - '|');
static auto headers = (quoted|bare) % '|' > (eol|eoi);
}
Headers parse_headers(std::string const& input) {
Headers output;
if (phrase_parse(begin(input), end(input), Grammar::headers, x3::blank, output))
return output;
return {}; // or throw, if you prefer
}
正在验证
这就是所谓的"semantic checks"。您获取字符串向量并根据您的逻辑检查它们：
#include <boost/range/adaptors.hpp>
#include <boost/algorithm/string.hpp>
bool header_match(Header const& actual, Header const& expected) {
using namespace boost::adaptors;
auto significant = [](unsigned char ch) {
return ch != '_' && std::isgraph(ch);
};
return boost::algorithm::iequals(actual | filtered(significant), expected);
}
bool headers_match(Headers const& actual, Headers const& expected) {
return boost::equal(actual, expected, header_match);
}
就是这样。算法和现代 C++ 的所有强大功能任您使用，无需因解析上下文而与约束作斗争。
完整演示
两个部分都变得更加简单：
- 您的解析器不必处理古怪的比较逻辑
- 您的比较逻辑不必处理语法问题（引号、转义符、定界符和空格）
我想解析文本文件的 header 列。列名应该允许被引用和字母的任何大小写。目前我正在使用以下语法：
#include <string>
#include <iostream>
#include <boost/spirit/include/qi.hpp>
namespace qi = boost::spirit::qi;
template <typename Iterator, typename Skipper>
struct Grammar : qi::grammar<Iterator, void(), Skipper>
{
static constexpr char colsep = '|';
Grammar() : Grammar::base_type(header)
{
using namespace qi;
using ascii::char_;
#define COL(name) (no_case[name] | ('"' >> no_case[name] >> '"'))
header = (COL("columna") | COL("column_a")) >> colsep >>
(COL("columnb") | COL("column_b")) >> colsep >>
(COL("columnc") | COL("column_c")) >> eol >> eoi;
#undef COL
}
qi::rule<Iterator, void(), Skipper> header;
};
int main()
{
const std::string s{"columnA|column_B|column_c\n"};
auto begin(std::begin(s)), end(std::end(s));
Grammar<std::string::const_iterator, qi::blank_type> p;
bool ok = qi::phrase_parse(begin, end, p, qi::blank);
if (ok && begin == end)
std::cout << "Header ok" << std::endl;
else if (ok && begin != end)
std::cout << "Remaining unparsed: '" << std::string(begin, end) << "'" << std::endl;
else
std::cout << "Parse failed" << std::endl;
return 0;
}
不使用宏是否可行？此外，我想完全忽略任何下划线。这可以通过自定义船长来实现吗？最后如果能这样写就完美了：
header = col("columna") >> colsep >> col("columnb") >> colsep >> column("columnc") >> eol >> eoi;
其中 col 是适当的语法或规则。
@sehe how can I fix this grammar to support
"\"Column_A\""as well? 6 hours ago
此时您可能已经意识到这里发生了两件不同的事情。
单独关注
一方面，您有一个 语法（允许 | 分隔的列，如 columna 或 "Column_A"）。
另一方面，您有语义分析（检查解析的内容是否符合特定条件的阶段）。
让你的生活变得艰难的是试图将两者混为一谈。现在，请不要误会我的意思，在（非常罕见的）情况下，绝对需要将这些职责融合在一起——但我认为这始终是一种优化。如果你需要它，Spirit 不是你的菜，你更有可能得到手写解析器的服务。
正在解析
所以让我们brain-dead简单了解一下语法：
static auto headers = (quoted|bare) % '|' > (eol|eoi);
bare 和 quoted 规则与以前几乎相同：
static auto quoted = lexeme['"' >> *('\' >> char_ | "\"\"" >> attr('"') | ~char_('"')) >> '"'];
static auto bare = *(graph - '|');
如您所见，这将隐含地处理引用和转义以及跳过词位外的空格。如果简单地应用，它将产生一个干净的列名列表：
std::string const s = "\"columnA\"|column_B| column_c \n";
std::vector<std::string> headers;
bool ok = phrase_parse(begin(s), end(s), Grammar::headers, x3::blank, headers);
std::cout << "Parse " << (ok?"ok":"invalid") << std::endl;
if (ok) for(auto& col : headers) {
std::cout << std::quoted(col) << "\n";
}
Parse ok
"columnA"
"column_B"
"column_c"
间奏曲：编码风格
让我们构造我们的代码以反映关注点分离。我们的解析代码可能使用 X3，但我们的验证代码不需要在同一个翻译单元（cpp 文件）中。
有一个 header 定义一些基本类型：
#include <string>
#include <vector>
using Header = std::string;
using Headers = std::vector<Header>;
定义我们要对它们执行的操作：
Headers parse_headers(std::string const& input);
bool header_match(Header const& actual, Header const& expected);
bool headers_match(Headers const& actual, Headers const& expected);
现在，main 可以重写为：
auto headers = parse_headers("\"columnA\"|column_B| column_c \n");
for(auto& col : headers) {
std::cout << std::quoted(col) << "\n";
}
bool valid = headers_match(headers, {"columna","columnb","columnc"});
std::cout << "Validation " << (valid?"passed":"failed") << "\n";
例如一个 parse_headers.cpp 可以包含：
#include <boost/spirit/home/x3.hpp>
namespace x3 = boost::spirit::x3;
namespace Grammar {
using namespace x3;
static auto quoted = lexeme['"' >> *('\' >> char_ | "\"\"" >> attr('"') | ~char_('"')) >> '"'];
static auto bare = *(graph - '|');
static auto headers = (quoted|bare) % '|' > (eol|eoi);
}
Headers parse_headers(std::string const& input) {
Headers output;
if (phrase_parse(begin(input), end(input), Grammar::headers, x3::blank, output))
return output;
return {}; // or throw, if you prefer
}
正在验证
这就是所谓的"semantic checks"。您获取字符串向量并根据您的逻辑检查它们：
#include <boost/range/adaptors.hpp>
#include <boost/algorithm/string.hpp>
bool header_match(Header const& actual, Header const& expected) {
using namespace boost::adaptors;
auto significant = [](unsigned char ch) {
return ch != '_' && std::isgraph(ch);
};
return boost::algorithm::iequals(actual | filtered(significant), expected);
}
bool headers_match(Headers const& actual, Headers const& expected) {
return boost::equal(actual, expected, header_match);
}
就是这样。算法和现代 C++ 的所有强大功能任您使用，无需因解析上下文而与约束作斗争。
完整演示
两个部分都变得更加简单：
- 您的解析器不必处理古怪的比较逻辑
- 您的比较逻辑不必处理语法问题（引号、转义符、定界符和空格）