Как я могу сохранить определенные семантические действия вне AST в boost :: spirit :: qi - PullRequest
Новая
       27

Как я могу сохранить определенные семантические действия вне AST в boost :: spirit :: qi

0 голосов
/ 24 августа 2018

У меня огромное количество файлов, которые я пытаюсь проанализировать с помощью 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 (мусор) к правилу запуска, так как lit () ничего не возвращает, но это не скомпилируется. Сбой: «статическое утверждение не выполнено: error_invalid_expression».

Я также пытался установить семантическое действие в правиле нежелательной почты на qi :: unused_type (), но в этом случае правило все еще создает пустой V ().

Мне известны следующие вопросы, но они не решают эту конкретную проблему. Я опробовал комментарий шкипера ранее, но похоже, что мне придется переопределить все правила разбора в шкипере, чтобы определить шум. Мой пример вдохновлен решением в последней ссылке:

Как пропустить комментарии строки / блока / вложенного блока в Boost.Spirit?

Как разобрать записи, за которыми следуют точка с запятой или новая строка (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 голосов
/ 26 августа 2018

Я попытался добавить lit (мусор) к правилу запуска, так как lit () ничего не возвращает, но это не скомпилируется.Он терпит неудачу с: «статическое утверждение не удалось: error_invalid_expression».

То, что вы ищете, будет omit[junk], но это не должно иметь никакого значения, потому что оно все равно сделает синтезированный атрибут optional<>.

Исправление вещей

  1. Прежде всего, вам нужны новые строки, чтобы быть значимыми.Что означает , вы не можете пропустить space.Потому что это ест новые строки.Что еще хуже, вам также нужно, чтобы начальные пробелы были значимыми (например, для отбрасывания последней строки).Тогда вы даже не можете использовать qi::blank для шкипера.(См. Проблемы шкипера повышения ).

    Точно так же вы можете иметь пробелы в правиле v, просто есть местный шкипер (который не ест переводы строки): 

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

    Он задействует шкипера только после установлениячто не было неожиданного начального пробела.

    Обратите внимание, что string("v") немного избыточен, но это подводит нас ко второму мотиву:

  2. Секундавсе, я с тобой избегаю семантических действий .Однако это означает, что вы должны сделать так, чтобы ваши правила отражали ваши структуры данных.

    В этом конкретном случае это означает, что вам, вероятно, следует перевернуть строку, пропуская немного наизнанку.Что если вы выразите грамматику как прямое повторение v, вкрапленное / любым / вместо простого / новой строки /?Я бы написал это так: 

    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;
}
0 голосов
/ 25 августа 2018

То, чего вы хотите достичь, называется исправлением ошибок.

К сожалению, у Spirit нет хорошего способа сделать это (есть также некоторые внутренние решения, которые затрудняют его внешнее).Тем не менее, в вашем случае это просто сделать с помощью грамматического переписывания. 

#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>()> {
        VGrammar() : VGrammar::base_type(start) {
            using namespace qi;

            v = skip(blank)[no_skip[string("v")] > double_ > double_ > double_];
            junk = +(char_ - eol);
            start = (v || -junk) % eol;

            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()> v;
        qi::rule<Iterator, std::vector<V>()> 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 = parse(iter, end, v_grammar, 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;
}
...