Aw.你正在做很棒的事情。可悲/幸运的是，它过于复杂了。

因此，让我们首先修复，然后简化。

错误

就像你说的，

void operator() (boost::iterator_range<It> const& id, boost::iterator_range<It> const& arg1, bool checking, Command& command) const

与实际调用的内容不匹配：

void Parser::deferred_fill::operator()(T&& ...) const [with T = {std::vector<char>&, std::vector<char>&, boost::iterator_range<boost::spirit::basic_istream_iterator<...> >&, Command&}]

原因不是迭代器(如您所见，它boost::spirit__istream_iterator没问题(。

但是，这是因为您正在获得其他属性。事实证明，*blank将该属性公开为vector<char>。因此，您可以通过omit[]来"修复"它们。让我们将其包装在像ignore这样的无属性规则中，以减少混乱。

现在调用是

void Parser::deferred_fill::operator()(T&& ...) const [with T = {boost::iterator_range<It>&, boost::iterator_range<It>&, bool&, Command&}]

所以它是兼容和编译的。解析：

SEND_CONFIRM("this is the id part", "this is arg1", TRUE);

跟

Parser parser;
parser.parse("file.txt");
std::cout << std::boolalpha;
for (auto& cmd : parser.commands) {
std::cout << '{' << cmd.id << ", "
<< cmd.arg1 << ", "
<< cmd.arg2 << ", "
<< cmd.checking << "}n";
}

指纹

{"this is the id part", "this is arg1", , TRUE}

让我们改进一下

• 这需要船长
• 这需要自动属性传播
• 风格的其他一些元素

船长

与其显式"调用"船长，不如使用内置功能：

rule<It, Attr(), Skipper> x;

定义一个规则，该规则跳过与Skipper类型的分析器匹配的输入序列。您需要实际传入该类型的船长。

• 使用qi::phrase_parse而不是qi::parse
• 通过使用qi::skip()指令

我一直提倡第二种方法，因为它使界面更友好，更不容易出错。

所以声明船长类型：

qi::rule<It, Command(), qi::blank_type> send;

我们可以将规则简化为：

send = (lit("SEND_CONFIRM") >> '(' 
>> raw[*~char_(',')] >> ','
>> raw[*~char_(',')] >> ','
>> value >> ')' >> ';')
[fill(_1, _2, _3, _val)];

而不是从start规则中传递船长：

start = skip(blank) [
(send[push_back(_val, _1)] | ignore) % eol
];

就这样。仍然编译和匹配相同。

住在科里鲁

使用词素跳过

仍然是相同的主题，lexemes实际上抑制了船长¹，因此您不必raw[].这会将公开的属性更改为vector<char>：

void operator() (std::vector<char> const& id, std::vector<char> const& arg1, bool checking, Command& command) const

住在科里鲁

自动属性传播

气有语义动作，但它的真正优势在于它们是可选的：提升精神："语义行为是邪恶的"？

• push_back(_val, _1)实际上是*p、+p和p % delim²的自动属性传播语义，所以只需删除它：

  start = skip(blank) [
  (send | ignore) % eol
  ];
  

  (请注意，send|ignore实际上合成了optional<Command>这对于自动传播来说是可以的(

• std::vector与std::string属性兼容，例如因此，如果我们可以为arg2添加一个占位符，我们可以匹配Command结构布局：

  send = lit("SEND_CONFIRM") >> '(' 
  >> attr(SEND) // fill type
  >> lexeme[*~char_(',')] >> ','
  >> lexeme[*~char_(',')] >> ','
  >> attr(std::string()) // fill for arg2
  >> value >> ')' >> ';'
  ;
  

  现在为了能够删除fill及其实现，我们必须将Command调整为融合序列：

  BOOST_FUSION_ADAPT_STRUCT(Command, type, id, arg1, arg2, checking)
  

样式 1 的元素

为您的命令类型使用命名空间可以更轻松地 ADL 使用命令的operator<<重载，因此我们可以std::cout << cmd;

这一点上，这一切都在代码的一小部分中工作：Live On Coliru

。

样式 2 的元素

• 如果可以，请将解析器设置为无状态。这意味着它可以是常量，所以你可以：

  • 无需昂贵的施工即可重复使用
  • 优化器还有更多工作要做
  • 它更可测试(有状态的东西更难证明幂等(

  因此，与其commands成员，不如返回它们。当我们使用它时，我们可以parse做一个静态函数。

• 无需对迭代器类型进行硬编码，而是可以灵活地将其作为模板参数。这样，您就不会受到multi_pass_adaptor和istream_iterator的开销的困扰，如果您在某个时候char[]缓冲区、string或string_view命令。

• 此外，使用合适的入口点从qi::grammar派生解析器意味着您可以将其用作解析器表达式(实际上是非终端，就像rule<>一样(与任何其他解析器一样。

• 考虑启用规则调试(请参阅示例(

完整代码

住在科里鲁

#define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
#include <fstream>
namespace qi = boost::spirit::qi;
namespace Commands {
enum TYPE { SEND, CHECK, COMMENT };
enum BOOL { FALSE, TRUE };
struct Command {
TYPE type;
std::string id;
std::string arg1;
std::string arg2;
BOOL checking;
};
typedef std::vector<Command> Commands;
// for (debug) output
static inline std::ostream& operator<<(std::ostream& os, TYPE t) {
switch (t) {
case SEND: return os << "SEND";
case CHECK: return os << "CHECK";
case COMMENT: return os << "COMMENT";
}
return os << "(unknown)";
}
static inline std::ostream& operator<<(std::ostream& os, BOOL b) {
return os << (b?"TRUE":"FALSE");
}
using boost::fusion::operator<<;
}
BOOST_FUSION_ADAPT_STRUCT(Commands::Command, type, id, arg1, arg2, checking)
namespace Commands {
template <typename It>
class Parser : public qi::grammar<It, Commands()> {
public:
Commands commands;
Parser() : Parser::base_type(start) {
using namespace qi;
value.add("TRUE", TRUE)
("FALSE", FALSE);
send = lit("SEND_CONFIRM") >> '(' 
>> attr(SEND) // fill type
>> lexeme[*~char_(',')] >> ','
>> lexeme[*~char_(',')] >> ','
>> attr(std::string()) // fill for arg2
>> value >> ')' >> ';'
;
ignore = +~char_("rn");
start = skip(blank) [
(send | ignore) % eol
];
BOOST_SPIRIT_DEBUG_NODES((start)(send)(ignore))
}
private:
qi::symbols<char, BOOL> value;
qi::rule<It> ignore;
qi::rule<It, Command(), qi::blank_type> send;
qi::rule<It, Commands()> start;
};
static Commands parse(std::istream& in) {
using It = boost::spirit::istream_iterator;
static const Parser<It> parser;
It first(in >> std::noskipws), //No white space skipping
last;
Commands commands;
if (!qi::parse(first, last, parser, commands)) {
throw std::runtime_error("command parse error");
}
return commands; // c++11 move semantics
}
}
int main() {
try {
for (auto& cmd : Commands::parse(std::cin))
std::cout << cmd << "n";
} catch(std::exception const& e) {
std::cout << e.what() << "n";
}
}

指纹

(SEND "this is the id part" "this is arg1"  TRUE)

或者确实定义了BOOST_SPIRIT_DEBUG：

<start>
<try>SEND_CONFIRM("this i</try>
<send>
<try>SEND_CONFIRM("this i</try>
<success>n</success>
<attributes>[[SEND, [", t, h, i, s,  , i, s,  , t, h, e,  , i, d,  , p, a, r, t, "], [", t, h, i, s,  , i, s,  , a, r, g, 1, "], [], TRUE]]</attributes>
</send>
<send>
<try></try>
<fail/>
</send>
<ignore>
<try></try>
<fail/>
</ignore>
<success>n</success>
<attributes>[[[SEND, [", t, h, i, s,  , i, s,  , t, h, e,  , i, d,  , p, a, r, t, "], [", t, h, i, s,  , i, s,  , a, r, g, 1, "], [], TRUE]]]</attributes>
</start>

¹ 根据需要预先跳过时;请参阅提升精神船长问题

²(然后是一些，但我们不要跑题(