Unintelligible compilation error for a simple X3 grammar

Question

I have a quite simple grammar I try to implement using boost spirit x3, without success.

It does not compile, and due to all the templates and complex concepts used in the library (I know, it is rather a "header"), the compilation error message is way too long to be intelligible.

I tried to comment part of the code in order narrow down the culprit, without success as it comes down to several parts, for which I don't see any error anyway.

Edit2: the first error message is in indeed in push_front_impl.hpp highlighting that:
::REQUESTED_PUSH_FRONT_SPECIALISATION_FOR_SEQUENCE_DOES_NOT_EXIST::*

I suspect the keyword auto or maybe the p2 statement with ulong_long...but with no faith. Need the help of you guys...spirit's elites !

Below a minimal code snippet reproducing the compilation error. Edit: using boost 1.70 and visual studio 2019 v16.1.6

#include <string>
#include <iostream>
#include "boost/spirit/home/x3.hpp"
#include "boost/spirit/include/support_istream_iterator.hpp"

int main(void)
{
       std::string input = \
             "\"nodes\":{ {\"type\":\"bb\", \"id\" : 123456567, \"label\" : \"0x12023049\"}," \
                         "{\"type\":\"bb\", \"id\" : 123123123, \"label\" : \"0x01223234\"}," \
                         "{\"type\":\"ib\", \"id\" : 223092343, \"label\" : \"0x03020343\"}}";
       std::istringstream iss(input);
       namespace x3 = boost::spirit::x3;
       using x3::char_;
       using x3::ulong_long;
       using x3::lit;
 
       auto q = lit('\"'); /* q => quote */
 
       auto p1 = q >> lit("type") >> q >> lit(':') >> q >> (lit("bb") | lit("ib")) >> q;
       auto p2 = q >> lit("id") >> q >> lit(':') >> ulong_long;
       auto p3 = q >> lit("label") >> q >> lit(':') >> q >> (+x3::alpha) >> q;
       auto node =  lit('{') >> p1 >> lit(',') >> p2 >> lit(',') >> p3 >> lit('}');
       auto nodes = q >> lit("nodes") >> q >> lit(':') >> lit('{') >> node % lit(',') >> lit('}');
 
       boost::spirit::istream_iterator f(iss >> std::noskipws), l{};
       bool b = x3::phrase_parse(f, l, nodes, x3::space);
 
       return 0;
}

Answer 1

It is an known MPL limitation (Issue with X3 and MS VS2017, https://github.com/boostorg/spirit/issues/515) + bug/difference of implementation for MSVC/ICC compilers (https://github.com/boostorg/mpl/issues/43).

I rewrote an offending part without using MPL (https://github.com/boostorg/spirit/pull/607), it will be released in Boost 1.74, until then you should be able to workaround with:

#define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
#define BOOST_MPL_LIMIT_VECTOR_SIZE 50

Alternatively you could wrap different parts of your grammar into rules, what will reduce sequence parser chain.

---

Note that q >> lit("x") >> q >> lit(':') >> ... probably is not what you really want, it (with a skipper) will allow " x ": to be parsed. If you do not want that use simply lit("\"x\"") >> lit(':') >> ...

Answer 2

There's a chance that there might be a missing indirect include for your specific platform/version (if I had to guess it might be caused by using the istream iterator support header from Qi).

If that's not the issue, my attention is drawn by the where T = boost::mpl::aux::vector_tag<20> (/HT @Rup - number 20 seems suspiciously like it might be some kind of limit.

Either we can find what trips the limit and see if we can raise it, but I'll do the "unscientific" approach in the interest of helping you along with the parser.

Simplifying The Expressions

I see a lot (lot) of lit() nodes in your parser expressions that you don't need. I suspect all the quoted constructs need to be lexemes, and instead of painstakingly repeating the quote symbol all over the place, perhaps package it as follows:

auto q = [](auto p) { return x3::lexeme['"' >> x3::as_parser(p) >> '"']; };
auto type  = q("type")  >> ':' >> q(bb_ib);
auto id    = q("id")    >> ':' >> x3::ulong_long;
auto label = q("label") >> ':' >> q(+x3::alnum);

Notes:

• I improved the naming so it's more natural to read:

  auto node = '{' >> type >> ',' >> id >> ',' >> label >> '}';
  

• I changed alpha to alnum so it would actually match your sample input

• Hypothesis: The expressions are structurally simplified to be more hierarchical - the sequences consist of fewer >>-ed terms - the hope is that this removes a potential mpl::vector size limit.

There's one missing piece, bb_ib that I left out because it changes when you want to actually assign parsed values to attributes. Let's do that:

Attributes

struct Node {
    enum Type { bb, ib } type;
    uint64_t id;
    std::string label;
};

As you can see I opted for an enum to represent type. The most natural way to parse that would be using symbols<>

struct bb_ib_sym : x3::symbols<Node::Type> {
    bb_ib_sym() { this->add("bb", Node::bb)("ib", Node::ib); }
} bb_ib;

Now you can parse into a vector of Node:

Demo

Live On Coliru

#include <boost/fusion/adapted/struct.hpp>
#include <boost/spirit/home/x3.hpp>
#include <iostream>
#include <iomanip>

struct Node {
    enum Type { bb, ib } type;
    uint64_t id;
    std::string label;
};

namespace { // debug output
    inline std::ostream& operator<<(std::ostream& os, Node::Type t) {
        switch (t) {
            case Node::bb: return os << "bb";
            case Node::ib: return os << "ib";
        }
        return os << "?";
    }
    inline std::ostream& operator<<(std::ostream& os, Node const& n) {
        return os << "Node{" << n.type << ", " << n.id << ", " << std::quoted(n.label) << "}";
    }
}

// attribute propagation
BOOST_FUSION_ADAPT_STRUCT(Node, type, id, label)

int main() {
    std::string input = R"("nodes": {
    {
        "type": "bb",
        "id": 123456567,
        "label": "0x12023049"
    },
    {
        "type": "bb",
        "id": 123123123,
        "label": "0x01223234"
    },
    {
        "type": "ib",
        "id": 223092343,
        "label": "0x03020343"
    }
})";

    namespace x3 = boost::spirit::x3;
    struct bb_ib_sym : x3::symbols<Node::Type> {
        bb_ib_sym() { this->add("bb", Node::bb)("ib", Node::ib); }
    } bb_ib;

    auto q = [](auto p) { return x3::lexeme['"' >> x3::as_parser(p) >> '"']; };
    auto type  = q("type")  >> ':' >> q(bb_ib);
    auto id    = q("id")    >> ':' >> x3::ulong_long;
    auto label = q("label") >> ':' >> q(+x3::alnum);
    auto node
        = x3::rule<Node, Node> {"node"}
        = '{' >> type >> ',' >> id >> ',' >> label >> '}';
    auto nodes = q("nodes") >> ':' >> '{' >> node % ',' >> '}';

    std::vector<Node> parsed;
    auto f = begin(input);
    auto l = end(input);
    if (x3::phrase_parse(f, l, nodes, x3::space, parsed)) {
        for (Node& node : parsed) {
            std::cout << node << "\n";
        }
    } else {
        std::cout << "Parse failed\n";
    }
    if (f!=l) {
        std::cout << "Remaining input: " << std::quoted(std::string(f, l)) << "\n";
    }
}

Prints

Node{bb, 123456567, "0x12023049"}
Node{bb, 123123123, "0x01223234"}
Node{ib, 223092343, "0x03020343"}