Как построить грамматику значения по умолчанию с помощью Boost Spirit?

Question

Я анализирую некоторый научный текст, формат которого выглядит примерно так:

Keyword
{ 1.0  22.2  59.6 'cm' 'yes' }

Я новичок в Spirit, и после изучения документа я могу использовать Spirit для поиска ключевого слова фиксированного формата.

Но в следующем формате я не знаю, как построить грамматику.Мой вопрос: в научном ключевом слове, с которым я встречался, некоторые элементы данных могут быть по умолчанию встроены в значения по умолчанию.Описание ключевого слова указывает, когда могут быть применены значения по умолчанию.Есть два способа установки количеств к их значениям по умолчанию.Во-первых, преждевременно заканчивая запись данных косой чертой '}', оставшиеся неопределенные величины устанавливаются в значения по умолчанию.Во-вторых, выбранные количества, расположенные до '}', можно ввести по умолчанию, введя n *, где n - количество последовательных количеств, которые должны быть по умолчанию.Например, 3 * приводит к тому, что следующим трем величинам в данных ключевого слова будут присвоены значения по умолчанию.

Например,

Person
{ 'Tom' 188 80 'male' 32 }

говорят, что "мужчина" и "32" являются значением по умолчаниюи его эквивалент может быть:

Person
{ 'Tom' 188 88 2* }

или

Person
{ 'Tom' 188 88 'male' 1* }

или

Person
{ 'Tom' 188 88 }

Я искал в прошлых сообщениях и это дает мне некоторое представление, но как я могу написать правило n *?

Answer 1

Парсер, который вы запрашиваете, очень сложен, так как должен решать несколько задач:

• обработать недостающие элементы в конце
• обрабатывать синтаксис "2 *" как замену отсутствующим элементам в конце
• правильно не только анализирует все допустимые входные данные, но также заполняет заданную структуру данных соответствующими значениями

Хитрость в том, чтобы использовать qi::attr по-разному:

• для предоставления значений по умолчанию для отсутствующих элементов:

  qi::int_ | qi::attr(180)
  

  т.е. либо соответствует целому числу, либо используйте значение по умолчанию 180

• для предоставления всех оставшихся значений для синтаксиса "2 *" (как предложено @vines):

  "2*" >> qi::attr(attr2)
  

  т.е. если 2* совпало, используйте значение по умолчанию attr2 (которое является fusion::vector).

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

#include <string>
#include <iostream>

#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/include/vector.hpp>

int main()
{
    namespace qi = boost::spirit::qi;
    namespace fusion = boost::fusion;

    // the attribute passed to the parser has to match (in structure) the 
    // parser, requiring to create nested fusion::vector's
    typedef fusion::vector<std::string, int>              attribute1_type;
    typedef fusion::vector<int, attribute1_type>          attribute2_type;
    typedef fusion::vector<int, attribute2_type>          attribute3_type;

    // overall attribute type
    typedef fusion::vector<std::string, attribute3_type>  attribute_type;

    // initialize attributes with default values
    attribute1_type attr1("male", 32);
    attribute2_type attr2(80, attr1);
    attribute3_type attr3(180, attr2);

    qi::rule<std::string::iterator, std::string()> quoted_string =
        "'" >> *~qi::char_("'") >> "'";

    qi::rule<std::string::iterator, attribute_type(), qi::space_type> data =
        qi::lit("Person") >> "{" 
            >>  quoted_string 
            >> -(   ("4*" >> qi::attr(attr3))
                |   (qi::int_ | qi::attr(180))
                    >> -(   ("3*" >> qi::attr(attr2))
                        |   (qi::int_ | qi::attr(80))
                            >> -(   ("2*" >> qi::attr(attr1))
                                |   (quoted_string | qi::attr("male"))
                                    >> -(   "1*"  
                                        |   qi::int_ 
                                        |   qi::attr(32)
                                        )
                                )
                        )
                )
        >> "}";

    std::string in1 = "Person\n{ 'Tom' 188 80 'male' 32 }";
    attribute_type fullattr1;
    if (qi::phrase_parse(in1.begin(), in1.end(), data, qi::space, fullattr1))
        std::cout << fullattr1 << std::endl;

    std::string in2 = "Person\n{ 'Tom' 188 80 'male' }";
    attribute_type fullattr2;
    if (qi::phrase_parse(in2.begin(), in2.end(), data, qi::space, fullattr2))
        std::cout << fullattr2 << std::endl;

    std::string in3 = "Person\n{ 'Tom' 188 3* }";
    attribute_type fullattr3;
    if (qi::phrase_parse(in3.begin(), in3.end(), data, qi::space, fullattr3))
        std::cout << fullattr3 << std::endl;

    return 0;
}

Разделение правила на отдельные правила (как предлагает @vines) потребует многократного анализа входных данных, поэтому я использовал эту вложенную структуру последовательностей и альтернатив.

Answer 2

Я только что придумал обобщенное решение, хотя оно немного сложнее =)
Он обрабатывает как «преждевременную скобку», так и несколько произвольных спецификаторов пропуска. Вот оно:

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/include/io.hpp>

#include <iostream>
#include <string>


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

struct numbers { int i1, i2, i3, i4; };

BOOST_FUSION_ADAPT_STRUCT
(numbers,
    (int, i1)
    (int, i2)
    (int, i3)
    (int, i4)
)

template <typename Iterator, typename Skipper>
struct Grammar : public qi::grammar <Iterator, numbers(), Skipper>
{
    Grammar() : Grammar::base_type(start, "numbers")
    {
    using qi::int_;

    // This rule resets the skip counter:
    init_skip = qi::eps[ph::ref(skp) = 0];

    // This rule parses the skip directive ("n*") and sets the skip counter:
    skip_spec = qi::omit[ (qi::lexeme[ int_ >> "*" ])[ph::ref(skp) = qi::_1] ];

    // This rule checks if we should skip the field, and if so, decrements
    // the skip counter and returns the value given to it (the default one).
    // If not, it tries to parse the int.
    // If int fails to parse, the rule resorts the default value again,
    // thus handling the "premature brace" case.
    int_dflt %= qi::eps(ph::ref(skp) > 0)[--ph::ref(skp)] >> qi::attr(qi::_r1) | int_ | qi::attr(qi::_r1);

    // And this is the grammar:
    start %= init_skip >>
             "{" >> -skip_spec >> int_dflt(-1)
                 >> -skip_spec >> int_dflt(-1)
                 >> -skip_spec >> int_dflt(-1)
                 >> -skip_spec >> int_dflt(-1)
                 >> "}";
    }

    // the skip counter itself:
    int skp;

    qi::rule <Iterator, numbers(), Skipper> start;
    qi::rule <Iterator, Skipper> skip_spec, init_skip;
    qi::rule <Iterator, int(int), Skipper> int_dflt;
};




int main (int argc, char **argv)
{
    using std::cout;
    using std::endl;

    std::string s = argv[1];

    numbers result;

    std::string::iterator ib = s.begin();
    std::string::iterator ie = s.end();
    bool r = qi::phrase_parse(ib, ie, Grammar<std::string::iterator, qi::space_type>(), qi::space, result );

    if (r && ib == ie)
    {
        cout << boost::fusion::tuple_open('[');
        cout << boost::fusion::tuple_close(']');
        cout << boost::fusion::tuple_delimiter(", ");

        cout << "Parsing succeeded\n";
        cout << "got: " << boost::fusion::as_vector(result) << endl;
    }
    else
    {
        cout << "Parsing failed\n";
        cout << "err: " << std::string(ib, ie) << endl;
    }

    return 0;
}

PS: обратите внимание, что аргумент шаблона Skipper не имеет никакого отношения к пропуску поля - это просто тип анализатора пропуска пробелов, используемого грамматикой.

Answer 3

Сначала я могу вспомнить:

Если в вашей структуре не слишком много членов, вы можете просто описать * n как некоторый синтаксис, то есть что-то вроде:

struct_full = "{" >> a >> b >> c >> "}";
struct_reduced_1 = "{" >> a >> b >> "1*" >> attr(c_default) >> "}"
struct_reduced_2 = "{" >> a >> "2*" >> attr(b_default) >> attr(c_default) >> "}";
struct_reduced_3 = "{" >> "3*" >> attr(a_default) >> attr(b_default) >> attr(c_default) >> "}";

Конечно, это не самый красивый способ ..