Как вы выводите исходный неразобранный код (как комментарий) из анализатора спирта - PullRequest
Новая
       5

Как вы выводите исходный неразобранный код (как комментарий) из анализатора спирта

1 голос
/ 04 февраля 2012

Учитывая входную строку: A = 23; B = 5, я в настоящее время получаю (ожидаемый) вывод: 

Output: 0xa0000023
Output: 0xa0010005
-------------------------

Я бы хотел увидеть это вместо: 

Output: 0xa0000023           // A = 23
Output: 0xa0010005           // B = 5
-------------------------

Основная строка кода: 

statement   = eps[_val = 0x50000000] >> identifier[_val += _1<<16] >>
                     "=" >> hex[_val += (_1 & 0x0000FFFF)];

Где идентификатор - это поиск таблицы qi :: символов.

Остальная часть моего кода выглядит так: 

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

#include <iostream>
#include <iomanip>
#include <ios>
#include <string>
#include <complex>

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

struct reg16_ : qi::symbols<char,unsigned> {
    reg16_() {
        add ("A", 0) ("B", 1) ("C", 2) ("D", 3) ;
    }
} reg16;

template <typename Iterator>
struct dash_script_parser : qi::grammar<Iterator, std::vector<unsigned>(), ascii::space_type> {
    dash_script_parser() : dash_script_parser::base_type(start) {
        using qi::hex;
        using qi::_val;
        using qi::_1;
        using qi::eps;

        identifier %= reg16;

        start      %= (statement % ";" );
        statement   = eps[_val = 0x50000000] >> identifier[_val += _1<<16]>> "=" >> hex[_val += (_1 & 0x0000FFFF)];
    }
    qi::rule<Iterator, std::vector<unsigned>(), ascii::space_type> start;
    qi::rule<Iterator, unsigned(), ascii::space_type> statement;
    qi::rule<Iterator, unsigned()> identifier;
};

int
main()
{
    std::cout << "\t\tA parser for Spirit...\n\n" << "Type [q or Q] to quit\n\n";

    dash_script_parser<std::string::const_iterator> g;
    std::string str;
    while (getline(std::cin, str))

    {
        if (str.empty() || str[0] == 'q' || str[0] == 'Q') break;

        std::string::const_iterator iter = str.begin();
        std::string::const_iterator end = str.end();
        std::vector<unsigned> strs;
        bool r = phrase_parse(iter, end, g, boost::spirit::ascii::space, strs);
        if (r && iter == end) {
            for(std::vector<unsigned>::const_iterator it=strs.begin(); it<strs.end(); ++it)
                std::cout << "Output: 0x" << std::setw(8) << std::setfill('0') << std::hex <<*it << "\n";
        } else
            std::cout << "Parsing failed\n";
    }
    return 0;
}

1 Ответ

4 голосов
/ 04 февраля 2012

Обновление Более новый ответ привлек мое внимание iter_pos (из репозитория Boost Spirit):

Это в основном то же самое, что и ниже, но без «злоупотребления» семантическими действиями (что делает его намного лучше подходящим, особенно с автоматическим распространением атрибутов.

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

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

1. Сделайте тип атрибута структурой

Замените примитив unsigned структурой, которая также содержит исходный фрагмент, дословно , как string: 

struct statement_t
{
    unsigned    value;
    std::string source;
};

BOOST_FUSION_ADAPT_STRUCT(statement_t, (unsigned, value)(std::string, source));

2. Заставить парсер заполнить оба поля

Хорошо, что вы уже использовали семантические действия, так что это просто наращивание. Обратите внимание, что результат не очень красивый, и он будет очень полезен, если его превратить в (слитый) функтор. Но это показывает технику очень четко: 

start      %= (statement % ";" );
statement   = qi::raw [ 
        raw[eps]      [ at_c<0>(_val)  = 0x50000000 ] 
        >> identifier [ at_c<0>(_val) += _1<<16 ]
        >> "=" >> hex [ at_c<0>(_val) += (_1 & 0x0000FFFF) ]
    ] 
    [ at_c<1>(_val) = construct<std::string>(begin(_1), end(_1)) ]
;

3. Печать

Итак, at_c<0>(_val) соответствует statement::value, а at_c<1>(_val) соответствует statement::source. Это слегка измененный выходной цикл: 

for(std::vector<statement_t>::const_iterator it=strs.begin(); it<strs.end(); ++it)
    std::cout << "Output: 0x" << std::setw(8) << std::setfill('0') << std::hex << it->value << " // " << it->source << "\n";
* * Выходы тысячи сорок четыре: 
Output: 0x50000023 // A = 23
Output: 0x50010005 // B = 5

Полный образец 

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

#include <iostream>
#include <iomanip>
#include <ios>
#include <string>
#include <complex>

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

#include <boost/spirit/include/phoenix_fusion.hpp>
#include <boost/spirit/include/phoenix_stl.hpp>
namespace phx   = boost::phoenix;

struct reg16_ : qi::symbols<char,unsigned> {
    reg16_() {
        add ("A", 0) ("B", 1) ("C", 2) ("D", 3) ;
    }
} reg16;

struct statement_t
{
    unsigned    value;
    std::string source;
};

BOOST_FUSION_ADAPT_STRUCT(statement_t, (unsigned, value)(std::string, source));

template <typename Iterator>
struct dash_script_parser : qi::grammar<Iterator, std::vector<statement_t>(), ascii::space_type> {
    dash_script_parser() : dash_script_parser::base_type(start) {
        using qi::hex;
        using qi::_val;
        using qi::_1;
        using qi::eps;
        using qi::raw;

        identifier %= reg16;

        using phx::begin;
        using phx::end;
        using phx::at_c;
        using phx::construct;

        start      %= (statement % ";" );
        statement   = raw [ 
                raw[eps]      [ at_c<0>(_val)  = 0x50000000 ] 
                >> identifier [ at_c<0>(_val) += _1<<16 ]
                >> "=" >> hex [ at_c<0>(_val) += (_1 & 0x0000FFFF) ]
            ] 
            [ at_c<1>(_val) = construct<std::string>(begin(_1), end(_1)) ]
        ;
    }
    qi::rule<Iterator, std::vector<statement_t>(), ascii::space_type> start;
    qi::rule<Iterator, statement_t(), ascii::space_type> statement;
    qi::rule<Iterator, unsigned()> identifier;
};

int
main()
{
    std::cout << "\t\tA parser for Spirit...\n\n" << "Type [q or Q] to quit\n\n";

    dash_script_parser<std::string::const_iterator> g;
    std::string str;
    while (getline(std::cin, str))

    {
        if (str.empty() || str[0] == 'q' || str[0] == 'Q') break;

        std::string::const_iterator iter = str.begin();
        std::string::const_iterator end = str.end();
        std::vector<statement_t> strs;
        bool r = phrase_parse(iter, end, g, boost::spirit::ascii::space, strs);
        if (r && iter == end) {
            for(std::vector<statement_t>::const_iterator it=strs.begin(); it<strs.end(); ++it)
                std::cout << "Output: 0x" << std::setw(8) << std::setfill('0') << std::hex << it->value << " // " << it->source << "\n";
        } else
            std::cout << "Parsing failed\n";
    }
    return 0;
}
...