Ошибка компиляции с boost :: spirit parser - PullRequest
Новая
       8

Ошибка компиляции с boost :: spirit parser

2 голосов
/ 26 февраля 2012

У меня странная проблема с калькулятором, созданным с использованием boost :: spirit.Предполагается, что этот калькулятор принимает строку в качестве аргумента, представляющего серию арифметических выражений, разделенных запятыми, например «a + 4 * 5,77, (bc) * 4».Это также позволяет строку "?"и возвращает массив, содержащий -1 в этом случае.Калькулятор инициализируется с помощью SymTable, который является аргументом класса шаблона для описания любого класса, предлагающего оператор [string] -> int (пример: карта), для разрешения значения переменных.

Следующий кодработает на моем Ubuntu 10.4 как с gcc 4.6.2, так и с gcc 4.4, а также с надстройками 1.47 и 1.48.В прошлом он также работал на компьютере Cray Linux с gcc 4.5.3 и boost 1.47.

#include <boost/bind.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>

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

namespace Damaris {

template <typename Iterator, typename SymTable>
struct Calc : qi::grammar<Iterator, std::vector<int>(), ascii::space_type>
{
        qi::rule<Iterator, std::vector<int>(), ascii::space_type> start;
        qi::rule<Iterator, int(), ascii::space_type> expr;
        qi::rule<Iterator, int(), ascii::space_type> qmark;
        qi::rule<Iterator, int(), ascii::space_type> factor;
        qi::rule<Iterator, int(), ascii::space_type> simple;
        qi::rule<Iterator, std::string(), ascii::space_type> identifier;
        qi::rule<Iterator, int(SymTable), ascii::space_type> value;

        /**
         * \brief Constructor.
         * \param[in] sym : table of symboles.
         */
        Calc(SymTable &sym) : Calc::base_type(start)
        {
                identifier = qi::lexeme[( qi::alpha | '_') >> *( qi::alnum | '_')];

                value   = identifier[qi::_val = qi::labels::_r1[qi::_1]];

                simple  = ('(' >> expr >> ')')
                        | qi::int_
                        | value(boost::phoenix::ref(sym));

                factor  %= (simple >> '*' >> factor)[qi::_val = qi::_1 * qi::_2]
                        |  (simple >> '/' >> factor)[qi::_val = qi::_1 / qi::_2]
                        |  (simple >> '%' >> factor)[qi::_val = qi::_1 % qi::_2]
                        |   simple;

                expr    %= (factor >> '+' >> expr)[qi::_val = qi::_1 + qi::_2]
                        |  (factor >> '-' >> expr)[qi::_val = qi::_1 - qi::_2]
                        |   factor;

                qmark   = qi::char_('?')[qi::_val = -1];

                start   = qmark
                        | (expr % ',');
        }
};

}

Сегодня я попытался снова скомпилировать тот же код на компьютере Cray (который с тех пор был обновлен, я думаю), я попытался с gcc 4.6.2 и gcc 4.5.2, и оба с boost1.48 и 1.49, и я всегда получаю ту же ошибку компиляции, которую я не понимаю: 

/nics/b/home/mdorier/damaris-0.4/common/Calc.hpp:74:3:   instantiated from 'Damaris::Calc<Iterator, SymTable>::Calc(SymTable&) [with Iterator = __gnu_cxx::__normal_iterator<const char*, std::basic_string<char> >, SymTable = Damaris::ParameterSet]'
/nics/b/home/mdorier/damaris-0.4/common/MetadataManager.cpp:45:79:   instantiated from here
/nics/b/home/mdorier/deploy/include/boost/spirit/home/qi/detail/assign_to.hpp:123:13: error: invalid static_cast from type 'const boost::fusion::vector2<int, int>' to type 'int'

Строка 74 в Calc.hpp соответствует строке "factor = ...".Указанная строка создания (MetadataManager.cpp: 45) выглядит следующим образом: 

layoutInterp = new Calc<std::string::const_iterator,ParameterSet>(*parameters);

с типом layoutInterp типа Calc * и параметрами типа ParameterSet *.

Любая идея, где возникает эта ошибкапроисходит от?Спасибо

1 Ответ

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

Я почти уверен, что вы, возможно, переставляли вещи в своих правилах.Фактически, %= автоматическое правило присваивания выражений не будет работать, потому что синтезированный тип выражения синтаксического анализатора не похож на int.

В принципе, вы быизменить 

factor %= (simple >> '*' >> factor)[ _val = _1 * _2 ]
    |  (simple >> '/' >> factor)[ _val = _1 / _2 ]
    |  (simple >> '%' >> factor)[ _val = _1 % _2 ]
    |   simple;

expr   %= (factor >> '+' >> expr)[ _val = _1 + _2 ]
    |  (factor >> '-' >> expr)[ _val = _1 - _2 ]
    |   factor;

на 

factor  = (simple >> '*' >> factor)[ _val = _1 * _2 ]
        | (simple >> '/' >> factor)[ _val = _1 / _2 ]
        | (simple >> '%' >> factor)[ _val = _1 % _2 ]
        | (simple) [_val = _1 ];

expr    = (factor >> '+' >> expr)[ _val = _1 + _2 ]
        | (factor >> '-' >> expr)[ _val = _1 - _2 ]
        | (factor) [_val = _1 ];

Я исправил несколько небольших проблем и создал SSCCE вашего поста, который работает, насколько я могу судить 1 : 

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/phoenix.hpp>

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

namespace Damaris {

    template <typename Iterator, typename SymTable>
    struct Calc : qi::grammar<Iterator, std::vector<int>(), ascii::space_type>
    {
        qi::rule<Iterator, std::vector<int>(), ascii::space_type> start;
        qi::rule<Iterator, int(), ascii::space_type> expr;
        qi::rule<Iterator, int(), ascii::space_type> qmark;
        qi::rule<Iterator, int(), ascii::space_type> factor;
        qi::rule<Iterator, int(), ascii::space_type> simple;
        qi::rule<Iterator, std::string(), ascii::space_type> identifier;
        qi::rule<Iterator, int(SymTable), ascii::space_type> value;

        Calc(SymTable &sym) : Calc::base_type(start)
        {
            using namespace qi;

            identifier = lexeme[( alpha | '_') >> *( alnum | '_')];

            value   = identifier[ _val = _r1[_1] ];

            simple  = ('(' >> expr >> ')')
                    | int_
                    | value(boost::phoenix::ref(sym));

            factor  = (simple >> '*' >> factor)[ _val = _1 * _2 ]
                    | (simple >> '/' >> factor)[ _val = _1 / _2 ]
                    | (simple >> '%' >> factor)[ _val = _1 % _2 ]
                    | (simple) [_val = _1 ];

            expr    = (factor >> '+' >> expr)[ _val = _1 + _2 ]
                    | (factor >> '-' >> expr)[ _val = _1 - _2 ]
                    | (factor) [_val = _1 ];

            qmark   = char_('?')[ _val = -1 ];

            start   = qmark 
                | (expr % ',');

            BOOST_SPIRIT_DEBUG_NODE(start);
            BOOST_SPIRIT_DEBUG_NODE(qmark);
            BOOST_SPIRIT_DEBUG_NODE(expr);
            BOOST_SPIRIT_DEBUG_NODE(factor);
            BOOST_SPIRIT_DEBUG_NODE(simple);
            BOOST_SPIRIT_DEBUG_NODE(value);
            BOOST_SPIRIT_DEBUG_NODE(identifier);
        }
    };

}

int main(int argc, const char *argv[])
{
    typedef std::map<std::string, int> SymTable;
    SymTable symbols;
    Damaris::Calc<std::string::const_iterator, SymTable> calc(symbols);

    symbols["TheAnswerToLifeUniverse"] = 100;
    symbols["Everything"] = -58;

    std::string input = "3*4+5/4, TheAnswerToLifeUniverse + Everything";
    std::string::const_iterator f(input.begin()), l(input.end());
    std::vector<int> data;

    if (qi::phrase_parse(f,l,calc,ascii::space,data))
        std::cout << "output: " << karma::format(karma::int_ % ", " << karma::eol, data);
    else
        std::cout << "problem: '" << std::string(f,l) << "'\n";

    return 0;
}

Выход: 

output: 13, 42

1 gcc 4.6.1, boost 1_48

...