我如何在boost :: spirit :: qi中阻止某些语义动作在AST中

时间：2018-08-24 13:04:32

标签： c++ boost-spirit boost-spirit-qi

我尝试使用boost :: spirit :: qi解析大量文件。解析不是问题，但是某些文件包含我要跳过的噪声。构建一个简单的解析器（不使用boost :: spirit :: qi）可以验证我是否可以通过跳过行首不符合规则的内容来避免产生噪音。因此，我正在寻找一种编写基于行的解析器的方法，该解析器在不匹配任何规则时会跳过行。

下面的示例允许语法在根本不匹配的情况下跳过行，但是“垃圾”规则仍会插入V（）的空实例，这是有害的行为。 在示例中使用\ r代替\ n是有意的，因为我在文件中同时遇到了\ n，\ r和\ r \ n。

#include <iostream>
#include <string>
#include <vector>
#include <boost/foreach.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/fusion/include/std_tuple.hpp>

namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
namespace phx = boost::phoenix;

using V = std::tuple<std::string, double, double, double>;

namespace client {
    template <typename Iterator>
    struct VGrammar : qi::grammar<Iterator, std::vector<V>(), ascii::space_type> {
        VGrammar() : VGrammar::base_type(start) {
            using namespace qi;

            v %= string("v") > double_ > double_ > double_;
            junk = +(char_ - eol);
            start %= +(v | junk);

            v.name("v");
            junk.name("junk");
            start.name("start");

            using phx::val;
            using phx::construct;

            on_error<fail>(
                start,
                std::cout
                    << val("Error! Expecting \n\n'")
                    << qi::_4
                    << val("'\n\n here: \n\n'")
                    << construct<std::string>(qi::_3, qi::_2)
                    << val("'")
                    << std::endl
            );

            //debug(v);
            //debug(junk);
            //debug(start);
        }

        qi::rule<Iterator> junk;
        //qi::rule<Iterator, qi::unused_type()> junk; // Doesn't work either
        //qi::rule<Iterator, qi::unused_type(), qi::unused_type()> junk; // Doesn't work either
        qi::rule<Iterator, V(), ascii::space_type> v;
        qi::rule<Iterator, std::vector<V>(), ascii::space_type> start;
    };
} // namespace client

int main(int argc, char* argv[]) {
    using iterator_type = std::string::const_iterator;

    std::string input = "";
    input += "v 1 2 3\r";         // keep v 1 2 3
    input += "o a b c\r";         // parse as junk
    input += "v 4 5 6 v 7 8 9\r"; // keep v 4 5 6, but parse v 7 8 9 as junk
    input += "   v 10 11 12\r\r"; // parse as junk

    iterator_type iter = input.begin();
    const iterator_type end = input.end();
    std::vector<V> parsed_output;
    client::VGrammar<iterator_type> v_grammar;

    std::cout << "run" << std::endl;
    bool r = phrase_parse(iter, end, v_grammar, ascii::space, parsed_output);
    std::cout << "done ... r: " << (r ? "true" : "false") << ", iter==end: " << ((iter == end) ? "true" : "false") << std::endl;

    if (r && (iter == end)) {
        BOOST_FOREACH(V const& v_row, parsed_output) {
            std::cout << std::get<0>(v_row) << ", " << std::get<1>(v_row) << ", " << std::get<2>(v_row) << ", " << std::get<3>(v_row) << std::endl;
        }
    }

    return EXIT_SUCCESS;
}

这是示例的输出：

run
done ... r: true, iter==end: true
v, 1, 2, 3
, 0, 0, 0
v, 4, 5, 6
v, 7, 8, 9
v, 10, 11, 12

这是我实际上希望解析器返回的内容。

run
done ... r: true, iter==end: true
v, 1, 2, 3
v, 4, 5, 6

我现在的主要问题是防止“垃圾”规则添加空V（）对象。我该如何完成？还是我想得太多了？

我尝试将lit（junk）添加到开始规则中，因为lit（）不返回任何内容，但是不会编译。它失败并显示：“静态断言失败：error_invalid_expression”。

我还尝试将垃圾规则的语义操作设置为qi :: unused_type（），但在这种情况下，规则仍会创建一个空的V（）。

我知道以下问题，但是他们没有解决这个特定问题。我早些时候已经尝试过注释船长，但是看来我必须重新实现船长中的所有解析规则才能识别噪音。我的示例受到最后一个链接中的解决方案的启发：

How to skip line/block/nested-block comments in Boost.Spirit?

How to parse entries followed by semicolon or newline (boost::spirit)?

版本信息：

Linux debian 4.9.0-7-amd64 #1 SMP Debian 4.9.110-3+deb9u2 (2018-08-13) x86_64 GNU/Linux
g++ (Debian 6.3.0-18+deb9u1) 6.3.0 20170516
#define BOOST_VERSION 106200

和：

Linux raspberrypi 4.14.24-v7+ #1097 SMP Mon Mar 5 16:42:05 GMT 2018 armv7l GNU/Linux
g++ (Raspbian 4.9.2-10+deb8u1) 4.9.2
#define BOOST_VERSION 106200

对于那些想知道的人：是的，我正在尝试解析类似于Wavefront OBJ文件的文件，并且我知道已经有很多解析器可用。但是，我正在解析的数据是较大数据结构的一部分，该数据结构也需要解析，因此构建新的解析器确实很有意义。

2 个答案:

答案 0 :(得分：3)

您要实现的目标称为错误恢复。

不幸的是，Spirit没有很好的方法来做（还有一些内部决策使得很难从外部进行构建）。但是，根据您的情况，通过语法重写很容易实现。

user_id_to

答案 1 :(得分：3)

  

我尝试将lit（junk）添加到开始规则中，因为lit（）不返回任何内容，但是不会编译。它失败并显示：“静态断言失败：error_invalid_expression”。

您要寻找的是omit[junk]，但它没有什么区别，因为它仍将构成综合属性optional<>。

修复问题

  1. 首先，您需要换行符才能有意义。您不能跳过哪个{em> ？space。因为它吃换行符。更糟糕的是，您还需要引导空格也要有意义（例如，使最后一行成为垃圾）。然后，您甚至不能将qi::blank用作该船长。 （请参见Boost spirit skipper issues）。

    因此，您仍然可以在v规则中保留空格，只需要使用本地船长（不吃换行符）即可：

    v %= &lit("v") >> skip(blank) [ string("v") > double_ > double_ > double_ ];

    仅在确定没有意外的前导空白后，才与船长接合。

    请注意，string("v")这样有点多余，但这将我们带到了第二个动机：

  2. 第二，我在avoiding semantic actions与您同在。但是，这意味着您必须使规则反映您的数据结构。

    在这种特定情况下，这意味着您可能应该将行跳过一点，由内而外。如果您将语法表示为v的直接重复，并穿插在/ whatever /中，而不仅仅是/ newline /，该怎么办？我会这样写：

    junk = *(char_ - eol);
other = !v >> junk;

start = *(v >> junk >> eol % other);

    请注意

    • 定界符表达式现在使用operator%（列表运算符）本身：(eol % other)。巧妙地实现的是，只要换行符仅由“其他”行（此时为!v所限定），它就会继续吃掉它们。
    • other比junk更加受限制，因为junk可能会吃掉v，而other确保永不发生
    • 因此，v >> junk可以正确处理示例的第三行（具有v 4 5 6 v 7 8 9\r的行）

现在一切正常： Live On Coliru ：

run
done ... r: true, iter==end: true
v, 1, 2, 3
v, 4, 5, 6

完美

您可能已经意识到，当第一行不是v行时，不能处理。让我们将该案例添加到示例中，并确保它也能正常工作：

Live On Coliru ：

//#define BOOST_SPIRIT_DEBUG
#include <iostream>
#include <string>
#include <vector>
#include <boost/foreach.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/fusion/include/std_tuple.hpp>

namespace qi = boost::spirit::qi;
namespace phx = boost::phoenix;

using V = std::tuple<std::string, double, double, double>;

namespace client {
    template <typename Iterator>
    struct VGrammar : qi::grammar<Iterator, std::vector<V>()> {
        VGrammar() : VGrammar::base_type(start) {
            using namespace qi;

            v %= &lit("v") >> skip(blank) [ string("v") > double_ > double_ > double_ ];
            junk = *(char_ - eol);
            other = !v >> junk;

            start = 
                other >> eol % other >>
                *(v >> junk >> eol % other);

            BOOST_SPIRIT_DEBUG_NODES((v)(junk)(start))

            on_error<fail>(
                start,
                std::cout
                    << phx::val("Error! Expecting \n\n'") << qi::_4
                    << "'\n\n here: \n\n'" << phx::construct<std::string>(qi::_3, qi::_2)
                    << "'\n"
            );
        }

      private:
        qi::rule<Iterator> other, junk;
        qi::rule<Iterator, V()> v;
        qi::rule<Iterator, std::vector<V>()> start;
    };
} // namespace client

int main() {
    using iterator_type = std::string::const_iterator;

    std::string input = "";
    input += "o a b c\r";         // parse as junk
    input += "v 1 2 3\r";         // keep v 1 2 3
    input += "o a b c\r";         // parse as junk
    input += "v 4 5 6 v 7 8 9\r"; // keep v 4 5 6, but parse v 7 8 9 as junk
    input += "   v 10 11 12\r\r"; // parse as junk

    iterator_type iter = input.begin();
    const iterator_type end = input.end();
    std::vector<V> parsed_output;
    client::VGrammar<iterator_type> v_grammar;

    std::cout << "run" << std::endl;
    bool r = parse(iter, end, v_grammar, parsed_output);
    std::cout << "done ... r: " << (r ? "true" : "false") << ", iter==end: " << ((iter == end) ? "true" : "false") << std::endl;

    if (iter != end)
        std::cout << "Remaining unparsed: '" << std::string(iter, end) << "'\n";

    if (r) {
        BOOST_FOREACH(V const& v_row, parsed_output) {
            std::cout << std::get<0>(v_row) << ", " << std::get<1>(v_row) << ", " << std::get<2>(v_row) << ", " << std::get<3>(v_row) << std::endl;
        }
    }

    return EXIT_SUCCESS;
}
相关问题
最新问题