Boost 从可选解析器表达式的可变列表生成Spirit解析器表达式

我正在寻找实现变量函数的最简单方法，它采用boost:：spirit:：qi规则列表，并将列表扩展为以下格式的表达式：rule1 | rule2 | rule3 |。。。。让我们假设规则不合成任何属性。非常感谢你的帮助

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

namespace qi    = boost::spirit::qi;
namespace ph    = boost::phoenix;
namespace ascii = boost::spirit::ascii;
using boost::spirit::qi::phrase_parse;
using boost::spirit::qi::ascii::space;
using boost::spirit::iso8859_1::char_;

typedef qi::rule<std::string::const_iterator,ascii::space_type> mrule_t;
typedef qi::rule< std::string::const_iterator,std::string() >   wrule_t;

#包括
#包括
#包括
#包括
#包括
名称空间qi=boost:：spirit:：qi；
名称空间ph=boost:：phoenix；
名称空间ascii=boost:：spirit:：ascii；
使用boost:：spirit:：qi:：短语解析；
使用boost:：spirit:：qi:：ascii:：space；
使用boost:：spirit:：iso8859_1:：char_u1；
类型定义qi：：规则规则；
typedef qi:：rulewrule\t；

---

//如何推导expandBitwise（）返回类型？
模板
按位扩展（T&T）
{
返回t.rule；
}
模板
按位扩展（T&T，尾部和…尾部）
{
返回t.rule 124;按位展开（尾部…）；
}
结构TStruct
{
规则；
模板
TStruct（T&rVar，const std:：string&name，R&rule）：
规则（qi:：lit（名称）>>规则[ph:：ref（rVar）=qi:：_1]）
{}
};
模板
void mparse（常量标准：：字符串和行、T&T、尾部和…尾部）
{
std:：string:：const_迭代器f，l；
f=行。开始（）；
l=line.end（）；

---

//我想在这里展开规则。。。
//if（短语解析（f，l，按位展开（t，tail…，空格）&&f==l）
if（短语解析（f，l，t.rule，space）&&f==l）
std:：cout您意外地从
expandBitwise
帮助程序返回了TStruct类型。请按如下方式修复它：

template<typename T>
auto expandBitwise(T const& t) -> decltype(t.rule_)
{
    return t.rule_;
}

template<typename T,typename ...Tail>
auto expandBitwise(T const& t,Tail const&... tail) -> decltype(t.rule_)
{
    return t.rule_ | expandBitwise(tail...);
}

诀窍在于：

shortopt = shortNames [_a = _1] >> lazy(_a);
longopt  = longNames  [_a = _1] >> lazy(_a);

其中
shortNames
和
longNames
是解析器的
qi:：symbols
表，基于
CliOptions
和
CliFlags
的可变列表动态构建（我将它们作为元组传递，因为我也想将结果存储在
CliOption
结构中）

qi:：lazy（_a）
调用存储在符号表中的解析器

另外，我的CliOptions解析器还具有生成“用法”信息的功能。解析表达式和用法信息的生成器是可扩展的

int main(int argc, char* argv[])
{
    using CliParsing::make_option;

    typedef std::string::const_iterator It;

    auto config = std::make_tuple(
        make_option('a', "absolutely", "absolutely"),
        make_option('b', "borked"    , "borked")    ,
        make_option('c', "completion", "completion"),
        make_option('d', "debug",      "turn on debugging"),
        make_option('e', "",           "no long name")  ,
        //make_option('f', "flungeons" , "flungeons") ,
        //make_option('g', "goofing"   , "")   ,
        //make_option('m', "monitor",    "monitoring level"),
        make_option('t', "testing"   , "testing flags"),
        make_option('\0',"file"      , "with a filename (no short name)"),

        make_option('y', "assume-yes", "always assume yes"),
        make_option('v', "verbose",    "increase verbosity level"),
        make_option('i', "increment",  "stepsize to increment with", 5)
        );

    CliParsing::OptionGrammar<It> parser(config);

    using namespace phx::arg_names;
    const auto cmdline = std::accumulate(argv+1, argv+argc, std::string(), arg1 + arg2 + '\0');

    bool ok = qi::parse(begin(cmdline), end(cmdline), parser);

    std::cout << "Parse success " << std::boolalpha << ok << "\n";
    std::cout << parser.getUsage();

    return ok? 0 : 255;
}

如您所见，尚未实现所有选项（值得注意的是，
--
标记选项列表的末尾）

谢谢你的提示！我刚刚尝试了你的代码，除非我做错了什么…我得到以下输出：
语法错误：abc 8.81已解析：-a atoken语法错误：-b btoken语法错误：-c ctoken语法错误：-d dtoken
–

好吧，所以，我不能离开它：/

事实证明，这涉及到未定义的行为，因为解析器表达式被传递到
expandBitwise
并被复制的方式：Boost原型表达式模板不是为了被复制而设计的，因为它们可能包含对临时对象的引用，临时对象的生命周期在其包含完整数据的结束时结束-表情

有关更多背景信息，请参阅

在使用
rule.alias（）
和
boost:：proto:：deepcopy
调整了很长（很长）时间后，我找到了以下解决方案（顺便说一句，它不再需要任何帮助函数）：

使用此代码，瞧，输出变成：

Syntax error:abc 8.81
Remaining unparsed: 'abc 8.81'
Parsed:-a atoken
Parsed:-b btoken
Parsed:-c ctoken
Parsed:-d dtoken
Bye

作为奖励，该代码现在允许您使用Spirit的内置debug（）功能（取消注释该行）：

谢谢你的提示！我刚刚尝试了你的代码，除非我做错了什么…我得到以下输出：语法错误：abc 8.81解析：-a atoken语法错误：-b b Token语法错误：-c ctoken语法错误：-d dtokenWell，我不希望你需要帮助调试语法。我假设问题是关于获得你的
expandBitwise
要编译的函数模板。您是否有时间了解Nabialek技巧（使用
qi:：symbols
而不是
r1 | r2 | r3 | r4
表单的“可变”表达式）“猜中了：-”，我一直在研究命令行解析器。主要是作为一个练习来尝试与Boost精神和C++相关的各种各样的方法。非常感谢你和我分享你的代码片段！好，准备好投票！我花了3个小时调试你的语法。结果比你想的要棘手。详细说明我提出的解决方案和完整的解释。干杯。你今天让我精神振奋！再次感谢：-）BRAVISSIMO MAESTRO！非常感谢你没有放弃我，坚持我最初的规范！！！正如前面所说，我更关心原则和见解，而不是优雅的解决方法，但我也很欣赏其他选择：-）我昨天被这个问题困住了，你的“解决方案”让我进入了一些新的领域：-）我有没有提到我仍然非常推荐使用qi:：symbols来解决这个问题？它不那么复杂，而且可能更具编译时/运行时效率（嗯，需要评测，但是谁评测了他的CLI参数解析器？这里更简单更有效）。我很想在以后的任务中玩弄一个合适的原型eDSL。我的待办事项列表中有qi:：symbols练习（如您在第一个答案中所述）。此答案中使用的实现和工具将让我忙碌一段时间：-）
shortopt = shortNames [_a = _1] >> lazy(_a);
longopt  = longNames  [_a = _1] >> lazy(_a);

int main(int argc, char* argv[])
{
    using CliParsing::make_option;

    typedef std::string::const_iterator It;

    auto config = std::make_tuple(
        make_option('a', "absolutely", "absolutely"),
        make_option('b', "borked"    , "borked")    ,
        make_option('c', "completion", "completion"),
        make_option('d', "debug",      "turn on debugging"),
        make_option('e', "",           "no long name")  ,
        //make_option('f', "flungeons" , "flungeons") ,
        //make_option('g', "goofing"   , "")   ,
        //make_option('m', "monitor",    "monitoring level"),
        make_option('t', "testing"   , "testing flags"),
        make_option('\0',"file"      , "with a filename (no short name)"),

        make_option('y', "assume-yes", "always assume yes"),
        make_option('v', "verbose",    "increase verbosity level"),
        make_option('i', "increment",  "stepsize to increment with", 5)
        );

    CliParsing::OptionGrammar<It> parser(config);

    using namespace phx::arg_names;
    const auto cmdline = std::accumulate(argv+1, argv+argc, std::string(), arg1 + arg2 + '\0');

    bool ok = qi::parse(begin(cmdline), end(cmdline), parser);

    std::cout << "Parse success " << std::boolalpha << ok << "\n";
    std::cout << parser.getUsage();

    return ok? 0 : 255;
}

short form option --increment parsed
ignoring unparsed argument: '3'
long form switch --completion parsed
short form switch --testing parsed
long form switch --file parsed
ignoring unparsed argument: '=SOME.TXT'
short form switch --borked parsed
ignoring unparsed argument: 'huh?'

Parse success true
 --absolutely (-a)
    absolutely (flag)
 --borked (-b)
    borked (flag)
 --completion (-c)
    completion (flag)
 --debug (-d)
    turn on debugging (flag)
 -e
    no long name (flag)
 --testing (-t)
    testing flags (flag)
 --file
    with a filename (no short name) (flag)
 --assume-yes (-y)
    always assume yes (flag)
 --verbose (-v)
    increase verbosity level (flag)
 --increment (-i)
    stepsize to increment with (option with value; default '5')

template<typename ...Tail>
void mparse(const std::string& line,Tail& ...tail)
{
    auto parser = boost::fusion::fold(
                boost::tie(ph::bind(&TStruct::rule_, arg1)(tail)...),
                qi::eps(false),
                deepcopy_(arg2 | arg1)
            );

    auto f=begin(line), l=end(line);

    if( qi::phrase_parse(f, l, parser, ascii::space ) )
        std::cout << "Parsed:" << line << std::endl;
    else
        std::cout << "Syntax error:" << line << std::endl;

    if (f!=l)
        std::cout << "Remaining unparsed: '" << std::string(f,l) << "'\n";
}

struct DeepCopy
{
    template<typename E> struct result { typedef typename boost::proto::result_of::deep_copy<E>::type type; };

    template<typename E>
        typename result<E>::type
        operator()(E const& expr) const {
            return boost::proto::deep_copy(expr);
        }
};

static const ph::function<DeepCopy> deepcopy_;

Syntax error:abc 8.81
Remaining unparsed: 'abc 8.81'
Parsed:-a atoken
Parsed:-b btoken
Parsed:-c ctoken
Parsed:-d dtoken
Bye

<-d>
  <try>abc 8.81</try>
  <fail/>
</-d>
<-c>
  <try>abc 8.81</try>
  <fail/>
</-c>
<-b>
  <try>abc 8.81</try>
  <fail/>
</-b>
<-a>
  <try>abc 8.81</try>
  <fail/>
</-a>
Syntax error:abc 8.81
Remaining unparsed: 'abc 8.81'

#define BOOST_RESULT_OF_USE_DECLTYPE
#define BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/fusion/adapted/boost_tuple.hpp>
#include <boost/fusion/include/fold.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>

namespace qi    = boost::spirit::qi;
namespace ph    = boost::phoenix;
namespace ascii = boost::spirit::ascii;
using namespace ph::arg_names;

typedef qi::rule<std::string::const_iterator,ascii::space_type> mrule_t;
typedef qi::rule<std::string::const_iterator,std::string() >    wrule_t;

struct TStruct
{
    mrule_t     rule_;
    template<typename T,typename R>
    TStruct( T& rVar,const std::string&name, R& rule ) :
        rule_( qi::lit(name) >> rule[ ph::ref(rVar) = qi::_1 ] )
    { 
        rule_.name(name);
        // debug(rule_);
    }
};

struct DeepCopy
{
    template<typename E> struct result { typedef typename boost::proto::result_of::deep_copy<E>::type type; };

    template<typename E>
        typename result<E>::type
        operator()(E const& expr) const {
            return boost::proto::deep_copy(expr);
        }
};

static const ph::function<DeepCopy> deepcopy_;

template<typename ...Tail>
void mparse(const std::string& line,Tail& ...tail)
{
    auto parser = boost::fusion::fold(
                boost::tie(ph::bind(&TStruct::rule_, arg1)(tail)...),
                qi::eps(false),
                deepcopy_(arg2 | arg1)
            );

    auto f=begin(line), l=end(line);

    if( qi::phrase_parse(f, l, parser, ascii::space ) )
        std::cout << "Parsed:" << line << std::endl;
    else
        std::cout << "Syntax error:" << line << std::endl;

    if (f!=l)
        std::cout << "Remaining unparsed: '" << std::string(f,l) << "'\n";
}

int main()
{
    wrule_t rword=+~ascii::space;

    std::string par1,par2,par3,par4;

    TStruct r1( par1, "-a", rword );
    TStruct r2( par2, "-b", rword );
    TStruct r3( par3, "-c", rword );
    TStruct r4( par4, "-d", rword );

    mparse("abc 8.81"   ,r1,r2,r3,r4);
    mparse("-a atoken"  ,r1,r2,r3,r4);
    mparse("-b btoken"  ,r1,r2,r3,r4);
    mparse("-c ctoken"  ,r1,r2,r3,r4);
    mparse("-d dtoken"  ,r1,r2,r3,r4);

    std::cout << "Bye\n";
}