boost::spirit::qi and access violation exception

Question

in the next simple code I receive the "access violation" exception. Why it happens? I can`t get the reason.

#define BOOST_SPIRIT_DEBUG
#include <boost/fusion/adapted/struct.hpp>
#include <boost/spirit/include/qi.hpp>

namespace qi = boost::spirit::qi;
typedef boost::spirit::ascii::space_type TSkipper;

struct MyField
{
    bool isConst;
    std::string mtype;
    std::string name;
};

BOOST_FUSION_ADAPT_STRUCT
    (
     MyField,
     (bool, isConst)
     (std::string, mtype)
     (std::string, name)
    )

template<typename Iterator, typename TSkipper = boost::spirit::ascii::space_type>
struct field_grammar : qi::grammar < Iterator, Field(), TSkipper >
{
    field_grammar() : field_grammar::base_type(field, "field_grammar")
    {
        // must parse values such as: int, list, i, j9_
        valid_symbols %= lexeme[qi::char_("a-zA-Z") > *(qi::char_("a-zA-Z0-9_"))];
        valid_symbols.name("valid_symbols");

        field %= qi::matches["const"] >> valid_symbols >> valid_symbols;
        field.name("field");

        BOOST_SPIRIT_DEBUG_NODES((valid_symbols)(field));
    }

    boost::spirit::qi::rule<Iterator, std::string(), TSkipper> valid_symbols;
    boost::spirit::qi::rule<Iterator, Field(), TSkipper> field;
};

And I use this grammar in the next way:

void SpiritTestSimple()
{
    std::string mdata = "int destroyWindow";

    std::string::const_iterator first = mdata.begin(), last = mdata.end();
    field_grammar<std::string::const_iterator> test_grammar;

    Field parsed;
    bool is_parsed;
    try
    {
        is_parsed = qi::phrase_parse(first, last, test_grammar, 
                                     boost::spirit::ascii::space, parsed);
    }
    catch (const qi::expectation_failure<std::string::const_iterator>& e)
    {
        std::string frag(e.first, e.last);
        std::cout << e.what() << "'" << frag << "'" << std::endl;
    }

    BOOST_ASSERT(is_parsed && "the example not parsed");
}

I receive the exception when executed the "qi::phrase_parse" function. Why it happens? And how to fix it? I use msvs2013.

Answer 1

I also use VS2013. It works okay, and I can't see much wrong with it except for long shots:

• you need to qualify qi::lexeme (with me that lead to a compilation error)
• you have Field reference that probably need to be MyField (this too should lead to a compilation error)
• technically, your program has undefined behaviour because is_parsed might be uninitialized in the ASSERT macro.

You could try the following version: Live On Coliru

#define BOOST_SPIRIT_DEBUG
#include <boost/fusion/adapted/struct.hpp>
#include <boost/spirit/include/qi.hpp>

namespace qi = boost::spirit::qi;

struct MyField
{
    bool        isConst = false;
    std::string mtype   = "";
    std::string name    = "";

    friend std::ostream& operator<<(std::ostream& os, MyField const& mf)
    {
        return os << "MyField[" 
                        << "isConst:" << std::boolalpha << mf.isConst 
                        << "\nmtype:" << mf.mtype
                        << "\nname: " << mf.name << "]";
    }
};

BOOST_FUSION_ADAPT_STRUCT
    (
     MyField,
     (bool, isConst)
     (std::string, mtype)
     (std::string, name)
    )

template<typename Iterator, typename TSkipper = boost::spirit::ascii::space_type>
struct field_grammar : qi::grammar <Iterator, MyField(), TSkipper>
{
    field_grammar() : field_grammar::base_type(field, "field_grammar")
    {
        // must parse values such as: int, list, i, j9_
        valid_symbols = qi::char_("a-zA-Z") >> *(qi::char_("a-zA-Z0-9_"));
        field         = qi::matches["const"] >> valid_symbols >> valid_symbols;

        BOOST_SPIRIT_DEBUG_NODES((valid_symbols)(field));
    }

    boost::spirit::qi::rule<Iterator, std::string()> valid_symbols;
    boost::spirit::qi::rule<Iterator, MyField(), TSkipper> field;
};

void SpiritTestSimple()
{
    std::string const mdata = "int destroyWindow";

    std::string::const_iterator first = mdata.begin(), last = mdata.end();
    field_grammar<std::string::const_iterator> test_grammar;

    try
    {
        MyField parsed;
        if (qi::phrase_parse(first, last, test_grammar, 
                                     boost::spirit::ascii::space, parsed))
        {
            std::cout << "Parsed: " << parsed << "\n";
        } else
        {
            std::cout << "Failed to parse '" << std::string(first, last) << "'\n";
        }
    }
    catch (const qi::expectation_failure<std::string::const_iterator>& e)
    {
        std::string frag(e.first, e.last);
        std::cout << e.what() << "'" << frag << "'" << std::endl;
    }

}

int main()
{
    SpiritTestSimple();
}

If that doesn't WorksForYou(TM) it's time to look at patch-levels, library versions, architecture, optimization flags and all that jazz.