Получил рабочий парсер для чтения описания позиций для настольной игры (международные шашки, официальная грамматика):

#include 
#include 

namespace x3 = boost::spirit::x3;

auto const colon   = x3::lit(':');
auto const comma   = x3::lit(',');
auto const dash    = x3::lit('-');
auto const dot     = x3::lit('.');    
auto const king    = x3::char_('K');
auto const color   = x3::char_("BW");
auto const num_sq  = x3::int_;

auto const num_pc  = -king >> num_sq;               // Kxx means king on square xx, xx a man on that square
auto const num_rng = num_pc >> dash >> num_sq;      // xx-yy means range of squares xx through yy (inclusive)
auto const num_seq = (num_rng | num_pc) % comma;    // <--- attribute should be std::vector
auto const ccn     = colon >> color >> -num_seq;
auto const num_not = x3::repeat(2)[ccn];            // need to specify both white and black pieces
auto const fen     = color >> num_not >> -dot;

Live On Coliru

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

namespace ast {

struct num_pc  { boost::optional k; int sq; };
struct num_rng { boost::optional k; int first, last; };
using rng_or_pc = boost::variant;
struct num_seq { std::vector sqrs; };
struct ccn     { char c; boost::optional seq; };
struct num_not { std::vector n; };
struct fen     { char c; num_not n; };

}   // namespace ast

BOOST_FUSION_ADAPT_STRUCT(ast::num_pc,  (boost::optional, k), (int, sq))
BOOST_FUSION_ADAPT_STRUCT(ast::num_rng, (boost::optional, k), (int, first), (int, last))
BOOST_FUSION_ADAPT_STRUCT(ast::num_seq, (std::vector, sqrs))
BOOST_FUSION_ADAPT_STRUCT(ast::ccn,     (char, c), (boost::optional, seq))
BOOST_FUSION_ADAPT_STRUCT(ast::num_not, (std::vector, n))
BOOST_FUSION_ADAPT_STRUCT(ast::fen,     (char, c), (ast::num_not, n))

x3::rule num_pc  = "num_pc";
x3::rule num_rng = "num_rng";
x3::rule num_seq = "num_seq";
x3::rule ccn     = "ccn";
x3::rule num_not = "num_not";
x3::rule fen     = "fen";

auto const colon   = x3::lit(':');
auto const comma   = x3::lit(',');
auto const dash    = x3::lit('-');
auto const dot     = x3::lit('.');    
auto const king    = x3::char_('K');
auto const color   = x3::char_("BW");
auto const num_sq  = x3::int_;

auto const num_pc_def  = -king >> num_sq;
auto const num_rng_def = num_pc >> dash >> num_sq;
auto const num_seq_def = (num_rng | num_pc) % comma;
auto const ccn_def     = colon >> color >> -num_seq;
auto const num_not_def = x3::repeat(2)[ccn];
auto const fen_def     = color >> num_not >> -dot;

BOOST_SPIRIT_DEFINE(num_pc, num_rng, num_seq, ccn, num_not, fen)

Live On Coliru

Однако затем я получаю сообщение об ошибке:

ошибка: static_assert failed "Атрибут не имеет ожидаемого значения. размер. "

и на пару страниц вниз:

^ main.cpp: 16: 8: note: конструктор-кандидат (конструктор неявного перемещения) нежизнеспособен: нет известного преобразования из 'std :: vector , std :: allocator >>'для 'ast :: num_seq' для первого аргумента struct num_seq { std :: vector sqrs; };

^ main.cpp: 16: 8: note: конструктор-кандидат (конструктор неявного копирования) не жизнеспособен: нет известного преобразования из 'std :: vector , std :: allocator >>'для 'const ast :: num_seq' для первого аргумента struct num_seq { std :: vector sqrs; };

Вопрос: откуда эта ошибка и как ее исправить? По-видимому, синтезированный атрибут моего правила num_seq не равен std :: vector >. Как это исправить?

Ответы (1)

Я потратил некоторое время, пытаясь понять грамматику.

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

Я предлагаю упрощенную версию, показанную ниже.

  • Поскольку ваша грамматика не использует рекурсию, нет реальной необходимости в правилах и помеченных типах синтаксического анализатора.
  • Также используйте пространство имен для артефактов парсера.
  • Рассмотрите возможность инкапсуляции с использованием шкипера вместо того, чтобы позволить вызывающей стороне решать (x3 :: skip [])
  • Добавьте несколько помощников, чтобы можно было распечатать AST для проверки:

    template  std :: ostream & operator << (std :: ostream & os, std :: vector  const & v) {
        os << "{"; for (auto & el: v) os << el << ""; return os << "}";
    }
    std :: ostream & оператор << (std :: ostream & os, num_pc const & p) {if (p.k) os << p.k; return os << p.sq; }
    std :: ostream & operator << (std :: ostream & os, num_rng const & r) {return os << r.pc << "-" << r.last; }
    std :: ostream & operator << (std :: ostream & os, ccn const & o) {return os << o.c << "" << o.seq; }
    std :: ostream & оператор << (std :: ostream & os, num_not const & nn) {return os << nn.n; }
    
  • Я бы не стал без надобности переносить и другой вектор:

    с использованием num_not = std :: vector ;
    
  • Используйте современные макросы ADAPT (поскольку вы используете C ++ 14 по определению):

    BOOST_FUSION_ADAPT_STRUCT (ast :: num_pc, k, sq)
    BOOST_FUSION_ADAPT_STRUCT (ast :: num_rng, pc, последний)
    BOOST_FUSION_ADAPT_STRUCT (ast :: ccn, c, seq)
    BOOST_FUSION_ADAPT_STRUCT (ast :: fen, c, n)
    
  • -

Живая демонстрация

Live On Coliru

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

namespace ast {

    struct num_pc {
        boost::optional k;
        int sq;
    };

    struct num_rng {
        num_pc pc;
        int last;
    };

    using rng_or_pc = boost::variant;
    using num_seq = std::vector;

    struct ccn {
        char c;
        boost::optional seq;
    };

    using num_not = std::vector;

    struct fen {
        char c;
        num_not n;
    };

    template  std::ostream& operator<<(std::ostream& os, std::vector const& v) {
        os << "{"; for (auto& el : v) os << el << " "; return os << "}";
    }
    std::ostream& operator<<(std::ostream& os, num_pc const& p)  { if (p.k) os << p.k; return os << p.sq; }
    std::ostream& operator<<(std::ostream& os, num_rng const& r) { return os << r.pc << "-" << r.last; }
    std::ostream& operator<<(std::ostream& os, ccn const& o)     { return os << o.c << " " << o.seq;                      } 
}

BOOST_FUSION_ADAPT_STRUCT(ast::num_pc,  k, sq)
BOOST_FUSION_ADAPT_STRUCT(ast::num_rng, pc, last)
BOOST_FUSION_ADAPT_STRUCT(ast::ccn,     c, seq)
BOOST_FUSION_ADAPT_STRUCT(ast::fen,     c, n)

namespace FEN {
    namespace x3 = boost::spirit::x3;

    namespace grammar
    {
        using namespace x3;

        template
            auto as = [](auto p) { return rule{} = as_parser(p); };

        uint_type const number {};
        auto const color   = char_("BW");
        auto const num_pc  = as  ( -char_('K') >> number          ); 
        auto const num_rng = as ( num_pc >> '-' >> number        ); 
        auto const num_seq = as ( (num_rng | num_pc) % ','       ); 
        auto const ccn     = as     ( ':' >> color >> -num_seq       ); 
        auto const num_not = as ( repeat(2)[ccn]                 ); 
        auto const fen     = as     ( color >> num_not >> -lit('.')  ); 
    }

    using grammar::fen;
}

int main() {
    for (std::string const t : {
        "B:W18,24,27,28,K10,K15:B12,16,20,K22,K25,K29",
        "B:W18,19,21,23,24,26,29,30,31,32:B1,2,3,4,6,7,9,10,11,12",
        "W:B1-20:W31-50",   // initial position
        "W:B:W",            // empty board
        "W:B1:W",           // only black pieces
        "W:B:W50"           // only white pieces
    }) {
        auto b = t.begin(), e = t.end();
        ast::fen data;
        bool ok = phrase_parse(b, e, FEN::fen, FEN::x3::space, data);

        std::cout << t << "\n";
        if (ok) {
            std::cout << "Parsed: " << boost::fusion::as_vector(data) << "\n";
        } else {
            std::cout << "Parse failed:\n";
            std::cout << "\t on input: " << t << "\n";
        }
        if (b != e)
            std::cout << "\t Remaining unparsed: '" << std::string(b, e) << '\n';
    }
}

Печать:

B:W18,24,27,28,K10,K15:B12,16,20,K22,K25,K29
Parsed: (B {W  {18 24 27 28  K10  K15 } B  {12 16 20  K22  K25  K29 } })
B:W18,19,21,23,24,26,29,30,31,32:B1,2,3,4,6,7,9,10,11,12
Parsed: (B {W  {18 19 21 23 24 26 29 30 31 32 } B  {1 2 3 4 6 7 9 10 11 12 } })
W:B1-20:W31-50
Parsed: (W {B  {1-20 } W  {31-50 } })
W:B:W
Parsed: (W {B -- W -- })
W:B1:W
Parsed: (W {B  {1 } W -- })
W:B:W50
Parsed: (W {B -- W  {50 } })

2022 WebDevInsider