c++ - boost::spirit::qi::parse 语法未按预期工作

c++ - boost::spirit::qi::parse 语法未按预期工作 - 第 2 部分

转载作者：行者123 更新时间：2023-11-30 03:49:54

几天前我问了这个question

一个开放点是不清楚如何处理值(在我的示例中为 -23.0)。字符串应被解析为值(表示为字符串类型)而不是选项。

我现在尝试扩展建议的语法，但还是没有成功。我也试图放宽我的要求，所以我认为用双破折号“--”定义一个参数是有效的。这个想法是为参数获取一个唯一标识符。这是我当前的语法，但解析失败，我不知道为什么:

//#define BOOST_SPIRIT_DEBUG
#include <boost/fusion/adapted.hpp>
#include <boost/spirit/include/qi.hpp>
#include <map>
#include <string>
#include <vector>

// Structure stores the parsed command line information:
struct CmdData
{
    typedef std::string               Name;

    typedef std::string               ArgName;
    typedef std::string               Value;

    typedef std::vector<Value>        Values;  // Type defines a list of values:
    typedef std::map<ArgName, Values> Args;    // Type defines a map storing the relation between a argument and the corresponding values:

    Name cmd; // Stores the command name as a string.
    Args arg; // Stores the arguments and the corresponding values as strings.
};

BOOST_FUSION_ADAPT_STRUCT(CmdData, (CmdData::Name, cmd)(CmdData::Args, arg))

namespace Grammar
{
    namespace qi = boost::spirit::qi;

    // This class implements the grammar used to parse a command line.
    // The expected format is as follows:
    // - command
    // - command value0 ... valueN
    // - command -arg0 ... -argN
    // - command -arg0 value0 ... valueN ... -argN value0 ... valueN
    template <typename It>
    struct decode : qi::grammar<It, CmdData()>
    {
    decode() : decode::base_type(data)
    {
        using namespace qi;

        token  = +( ~char_( "\r\n -" ) );
        values = +( ~char_( "--" ) >> +token );

        //
        entry  = (lexeme[ "--" >> token ] >> -values | attr( "empty" ) >> values );
        args   = *entry;

        //
        data   = skip(qi::blank) [ token >> args ];

        BOOST_SPIRIT_DEBUG_NODES( (token)(values)(entry)(args)(data) )
    }

private:
    qi::rule<It, CmdData()> data;

    // The following variables define the rules used within this grammar:
    typedef std::pair<CmdData::ArgName, CmdData::Values> Entry;
    qi::rule<It, CmdData::Values(), qi::blank_type> values;
    qi::rule<It, Entry(),           qi::blank_type> entry;
    qi::rule<It, CmdData::Args(),   qi::blank_type> args;

    // lexemes
    qi::rule<It, std::string()> token;
    };

}   // namespace

bool parse(const std::string& in)
{
    CmdData data;

    // Create an instance of the used grammar:
    Grammar::decode<std::string::const_iterator> gr;

    // Try to parse the data stored within the stream according the grammar and store the result in the tag variable:
    bool b = boost::spirit::qi::parse(in.begin(), in.end(), gr, data);

    std::cout << "Parsing: '" << in << "' ok: " << std::boolalpha << b << "\n";
    if (b)
        std::cout << "Entries parsed: " << data.arg.size() << "\n";

    return b;
}

int main()
{
    parse("   cmd0");
    parse("   cmd0        value0  value1  value2 -23.0");
    parse("   cmd0  -23.0 value0  value1  value2");
    parse("   cmd0  --arg0  --arg1  123 --arg2 -23.0");
    parse("   cmd0  --arg0  value0  --arg1  value0  value1  --arg2  value0  value1  value2");
}

最佳答案

好的，我试过你的语法，我想我成功了。

声明一下，我不是 boost spirit 的专家，我只有中等水平的经验。

以下是我更改的内容:

我不知道 ~ 运算符的本质是什么，这里没有记录:http://www.boost.org/doc/libs/1_44_0/libs/spirit/doc/html/spirit/qi/reference/operator.html在我的版本中，我删除了它。
我认为您使用 ~ 试图表示“不是这些字符”。我这样做的方式通常是使用 - 运算符。也就是说，我创建了一个“通用”表达式，然后使用 - 从中排除了一些内容。
我去掉了你所有的跳过语法，只添加了一个空格规则。只要空白规则没有属性，就不会影响自动属性扣除，它会有qi::unused_type。这可能不是必需的/最佳的，但以这种方式做出有效的回答对我来说更快。
我认为我在您的语法中修复的两个主要问题是，使用 ~char_( "--") 而您应该使用 - "-- " 或 - lit("--") 正如 cv_and_he 在评论中指出的那样，以及您解析参数类的部分 "--">> token 并且没有使用 lit，这肯定会混淆自动属性收集系统。

这是我最终得到的结果:

#define BOOST_SPIRIT_USE_PHOENIX_V3

#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_object.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_fusion.hpp>
#include <boost/spirit/include/phoenix_stl.hpp>
#include <boost/fusion/adapted/struct/adapt_struct.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/include/std_pair.hpp>

#include <string>
#include <vector>

// Structure stores the parsed command line information:
struct CmdData
{
    typedef std::string               Name;

    typedef std::string               ArgName;
    typedef std::string               Value;

    typedef std::vector<Value>        Values;  // Type defines a list of values:
    typedef std::map<ArgName, Values> Args;    // Type defines a map storing the relation between a argument and the corresponding values:

    Name cmd; // Stores the command name as a string.
    Args arg; // Stores the arguments and the corresponding values as strings.
};

BOOST_FUSION_ADAPT_STRUCT(CmdData, (CmdData::Name, cmd)(CmdData::Args, arg))

namespace Grammar
{
    namespace qi = boost::spirit::qi;

    // This class implements the grammar used to parse a command line.
    // The expected format is as follows:
    // - command
    // - command value0 ... valueN
    // - command -arg0 ... -argN
    // - command -arg0 value0 ... valueN ... -argN value0 ... valueN
    template <typename It>
    struct decode : qi::grammar<It, CmdData()>
    {
    decode() : decode::base_type(data)
    {
        using namespace qi;

        ws = char_("\r\n ");
        token  = +( char_ - ws - lit("--") );
        values = token % (+ws);

        //
        arg_label = lit("--") >> token;
        entry  = arg_label >> -(+ws >> values);
        args   = entry % (+ws);

        //
        data   = *ws >> token >> -(+ws >> args) >> *ws;

        BOOST_SPIRIT_DEBUG_NODES( (token)(values)(entry)(args)(data) )
    }

private:
    qi::rule<It, CmdData()> data;

    // The following variables define the rules used within this grammar:
    typedef std::pair<CmdData::ArgName, CmdData::Values> Entry;
    qi::rule<It, CmdData::Values()> values;
    qi::rule<It, Entry()> entry;
    qi::rule<It, CmdData::Args()> args;

    // lexemes
    qi::rule<It, std::string()> token;
    qi::rule<It, std::string()> arg_label;
    qi::rule<It> ws;
    };

}   // namespace

bool parse(const std::string& in)
{
    CmdData data;

    // Create an instance of the used grammar:
    Grammar::decode<std::string::const_iterator> gr;

    // Try to parse the data stored within the stream according the grammar and store the result in the tag variable:
    bool b = boost::spirit::qi::parse(in.begin(), in.end(), gr, data);

    std::cout << "Parsing: '" << in << "' ok: " << std::boolalpha << b << "\n";
    if (b) {
        std::cout << "Entries parsed: " << data.arg.size() << "\n";

        for (const auto & p : data.arg) {
            std::cout << "  " << p.first;
            bool first = true;
            for (const auto & v : p.second) {
                if (first) {
                    std::cout << " : ";
                    first = false;
                } else {
                    std::cout << " , ";
                }
                std::cout << v;
            }
        std::cout << std::endl;
        }
    }

    return b;
}

int main()
{
    parse("   cmd0");
    parse("   cmd0        value0  value1  value2 -23.0");
    parse("   cmd0  -23.0 value0  value1  value2");
    parse("   cmd0  --arg0  --arg1  123 --arg2 -23.0");
    parse("   cmd0  --arg0  value0  --arg1  value0  value1  --arg2  value0  value1  value2");
}

使用 gcc 版本 4.8.4 编译。这是我的输出:

$ g++ -std=c++11 main.cpp -o main
$ ./main 
Parsing: '   cmd0' ok: true
Entries parsed: 0
Parsing: '   cmd0        value0  value1  value2 -23.0' ok: true
Entries parsed: 0
Parsing: '   cmd0  -23.0 value0  value1  value2' ok: true
Entries parsed: 0
Parsing: '   cmd0  --arg0  --arg1  123 --arg2 -23.0' ok: true
Entries parsed: 3
  arg0
  arg1 : 123
  arg2 : -23.0
Parsing: '   cmd0  --arg0  value0  --arg1  value0  value1  --arg2  value0  value1  value2' ok: true
Entries parsed: 3
  arg0 : value0
  arg1 : value0 , value1
  arg2 : value0 , value1 , value2

编辑:

正如评论中指出的那样，我的第一个答案是不正确的，因为它不处理“空”参数类型。我现在看到第 1 部分的答案正确地完成了该部分。在这个版本中，我修复了这个问题，还修复了空格，以便处理得更干净/更像原始代码示例。

#define BOOST_SPIRIT_USE_PHOENIX_V3

#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_object.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_fusion.hpp>
#include <boost/spirit/include/phoenix_stl.hpp>
#include <boost/fusion/adapted/struct/adapt_struct.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/include/std_pair.hpp>

#include <string>
#include <vector>

// Structure stores the parsed command line information:
struct CmdData
{
    typedef std::string               Name;

    typedef std::string               ArgName;
    typedef std::string               Value;

    typedef std::vector<Value>        Values;  // Type defines a list of values:
    typedef std::map<ArgName, Values> Args;    // Type defines a map storing the relation between a argument and the corresponding values:

    Name cmd; // Stores the command name as a string.
    Args arg; // Stores the arguments and the corresponding values as strings.
};

BOOST_FUSION_ADAPT_STRUCT(CmdData, (CmdData::Name, cmd)(CmdData::Args, arg))

namespace Grammar
{
    namespace qi = boost::spirit::qi;

    // This class implements the grammar used to parse a command line.
    // The expected format is as follows:
    // - command
    // - command value0 ... valueN
    // - command -arg0 ... -argN
    // - command -arg0 value0 ... valueN ... -argN value0 ... valueN
    template <typename It>
    struct decode : qi::grammar<It, CmdData()>
    {
    decode() : decode::base_type(data)
    {
        using namespace qi;

        token  = +( char_ - blank - lit("--") );

        //
        arg_label = lit("--") >> token;
        entry  = skip(blank) [
                     (arg_label >> *token) | ( attr("empty") >> +token)
                 ];
        args   = *entry;

        //
        data   = skip(blank) [ token >> args ];

        BOOST_SPIRIT_DEBUG_NODES( (token)(entry)(args)(arg_label)(data) )
    }

private:
    qi::rule<It, CmdData()> data;

    // The following variables define the rules used within this grammar:
    typedef std::pair<CmdData::ArgName, CmdData::Values> Entry;
    qi::rule<It, Entry()> entry;
    qi::rule<It, CmdData::Args()> args;

    // lexemes
    qi::rule<It, std::string()> token;
    qi::rule<It, std::string()> arg_label;
    };

}   // namespace

bool parse(const std::string& in)
{
    CmdData data;

    // Create an instance of the used grammar:
    Grammar::decode<std::string::const_iterator> gr;

    // Try to parse the data stored within the stream according the grammar and store the result in the tag variable:
    bool b = boost::spirit::qi::parse(in.begin(), in.end(), gr, data);

    std::cout << "Parsing: '" << in << "' ok: " << std::boolalpha << b << "\n";
    if (b) {
        std::cout << "Entries parsed: " << data.arg.size() << "\n";

        for (const auto & p : data.arg) {
            std::cout << "  " << p.first;
            bool first = true;
            for (const auto & v : p.second) {
                if (first) {
                    std::cout << " : ";
                    first = false;
                } else {
                    std::cout << " , ";
                }
                std::cout << v;
            }
        std::cout << std::endl;
        }
    }

    return b;
}

int main()
{
    parse("   cmd0");
    parse("   cmd0        value0  value1  value2 -23.0");
    parse("   cmd0  -23.0 value0  value1  value2");
    parse("   cmd0  --arg0  --arg1  123 --arg2 -23.0");
    parse("   cmd0  --arg0  value0  --arg1  value0  value1  --arg2  value0  value1  value2");
}

我的输出现在是这样的:

$ ./main 
Parsing: '   cmd0' ok: true
Entries parsed: 0
Parsing: '   cmd0        value0  value1  value2 -23.0' ok: true
Entries parsed: 1
  empty : value0 , value1 , value2 , -23.0
Parsing: '   cmd0  -23.0 value0  value1  value2' ok: true
Entries parsed: 1
  empty : -23.0 , value0 , value1 , value2
Parsing: '   cmd0  --arg0  --arg1  123 --arg2 -23.0' ok: true
Entries parsed: 3
  arg0
  arg1 : 123
  arg2 : -23.0
Parsing: '   cmd0  --arg0  value0  --arg1  value0  value1  --arg2  value0  value1  value2' ok: true
Entries parsed: 3
  arg0 : value0
  arg1 : value0 , value1
  arg2 : value0 , value1 , value2

我不得不在那个版本中稍微改变一下，因为我得到了一个无限循环 *entry 然后是 attr("empty") >> *tokens。我认为这很可能是在仍然使用所有自动归因的同时让它发挥作用的最简单方法，我不确定。

关于c++ - boost::spirit::qi::parse 语法未按预期工作 - 第 2 部分，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32158007/

文章推荐：安卓果冻 bean 4.1.2 : People app doesn't display birthday event

文章推荐： c++ - 如何计算冒泡排序中的交换？

文章推荐： c++ - 如何找到 vector 中的最大元素 (C++)？

语法
在此处回答的另一个问题中，我发现了以下 JavaScript代码: function _dom_trackActiveElement(evt) { if (evt && evt.target)
语法
if (A == 0) OR (B == 0) 怎么说？最佳答案只是为了讽刺: if (A === 0 || B === 0) 关于语法，我们在Stack Overflow上找到一个类似的问题：
语法
var ret = [] ,xresult = document.evaluate(exp, rootEl, null, X
语法
我一直在寻找一些类似于下例的 JavaScript。有人可以解释一下吗，因为我以前从未见过这样编写的 JavaScript。 “SomethingHere”和冒号代表什么？我习惯于看到函数 myFun
mysql程序: syntax,语法，语法……太难找了
这是我的程序: delimiter // drop procedure if exists migContactToActor; create procedure migContactToActor(
c - 从 icc 获取 Intel 语法 asm 输出，而不是默认的 AT&T 语法？
我遇到了一个问题。我一直在使用 gcc 编译/汇编我的 C 代码一段时间，并且习惯了阅读 Intel 汇编语法。我在生成程序集文件时使用了 -masm=intel 标志。但是最近因为公司迁移，拿到了
语法:自上而下和自下而上的区别？
自上而下和自下而上语法有什么区别？举个例子就太好了。最佳答案首先，语法本身不是自上而下或自下而上的，解析器是(尽管有些语法可以被其中一个解析，但不能被另一个解析)。从实践的角度来看，主要区别在于
AppleScript 语法
我知道这是草率的代码，但它是: display dialog ("Start Screensaver. Please type: matrix, coffee, waffles, star, wate
Java 语法 ": "
这个问题已经有答案了: Giving name to a loop (6 个回答) 已关闭 8 年前。我见过这个字符在 C# 中使用，就像 Java 中的扩展一样，但最近我在代码中发现了这个 loo
在函数中通过指针调用字符串(语法)
我正在尝试编写一个函数来检查字符串是否为回文，但我认为在使用字符串指针时存在一些错误。这段代码有什么问题？ #include #include #define MAX 1000 int IsPalin
Javascript "for"语法
所以在this question我询问了一些 Javascript 是如何被压缩的。问题已得到解答，但以下片段让我非常困惑，以至于我不得不问另一个问题。在这里: for (Y = 0; $ = 'zx
调用函数指针(语法)
假设我有一个接受这些参数的函数。 int create(Ptr * p,void * (*insert)(void *, void *)) { //return something later } 结
C语言未知&语法
这个问题已经有答案了: Bitwise '&' operator (6 个回答) 已关闭 5 年前。我在代码中找到了这个，但我从未遇到过像 & 这样的事情，仅 && if ((code & 1) =
使用继承的c++语法
我在处理继承类及其中的构造函数和方法的语法时遇到了问题。我想实现一个类日期和一个子类 date_ISO，它们将按特定顺序设置给定的日、月、年，并通过一种方法将其写入字符串。我觉得我的基类日期工作正常
MySQL IF THEN AS 语法
我正在尝试通过存储过程填充表，如下所示: SET @resultsCount = (SELECT COUNT(*) FROM tableA); SET @i = 0; WHILE @i THEN
Bash 语法 : What is the "<<"?
谁能解释一下下面代码中的“<<”？ mysql test<
MySQL OR AND 语法
刚刚开始学习 MySQL，这是一个菜鸟问题，也是我在 StackOverflow 上的第一个问题。假设我有 12 个订单状态，我想从其中的 5 个中选择总计。我会使用: SELECT SUM(tot
JavaScript 语法
我的编程背景是在学校学过一点Java。由于某些原因，JavaScript 语法往往让我感到困惑。下面的 JavaScript 代码是一种我不知道如何构成的语法模式: foo.ready = funct
JavaScript 语法 $
我正在阅读 javascript 源代码，并且我以前没有编写过 javascript。我对它的一些语法感到困惑。 $(function () { window.onload=function
JavaScript 语法？
我什至不知道如何命名我想要的东西。那么让我举个例子来解释一下。虽然火狐使用textContent，但其他浏览器支持innerText属性。顺便说一句，如果我使用了错误的术语，请纠正我。无论如何，到目

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c++ - boost::spirit::qi::parse 语法未按预期工作 - 第 2 部分