Ticket #9260: phx_3_crash_reproducer.cpp

#define BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/fusion/adapted.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>

namespace qi    = boost::spirit::qi;
namespace phx   = boost::phoenix;

// an enum defining possible operators
typedef enum builtin_operator_tag {
        OPERATOR_LT = 0,
        OPERATOR_LTE,
        OPERATOR_GT,
        OPERATOR_GTE,
        OPERATOR_EQ,
        OPERATOR_NEQ
} builtin_operator_number;

// then the using statement in a rule with lots of local variables
template <typename It, typename Skipper = qi::space_type>
struct parser : qi::grammar<It, bool(), Skipper> {

        parser() : parser::base_type(start) {

                using namespace qi;

                cmp_operators.add
                        (">",    OPERATOR_GT )
                        (">=",   OPERATOR_GTE)
                        ("=>",   OPERATOR_GTE)
                        ("<",    OPERATOR_LT )
                        ("=<",   OPERATOR_LTE)
                        ("<=",   OPERATOR_LTE)
                        ("==",   OPERATOR_EQ )
                        ("!=",   OPERATOR_NEQ);

                condition =  ( double_ >> lexeme [ cmp_operators ] >> double_ )
                        [
                                phx::switch_(_2)[
                                        phx::case_<OPERATOR_GT> (_val = (_1  > _3)),
                                        phx::case_<OPERATOR_GTE>(_val = (_1 >= _3)),
                                        phx::case_<OPERATOR_LT> (_val = (_1  < _3)),
                                        phx::case_<OPERATOR_LTE>(_val = (_1 <= _3)),
                                        phx::case_<OPERATOR_EQ> (_val = (_1 == _3)),
                                        phx::case_<OPERATOR_NEQ>(_val = (_1 != _3)),
                                        phx::default_(_val = false)
                                ]
                        ];

                enclosing %= condition[_a = _1] >> double_[_val = _a];               // works
//              enclosing %= condition[_a = _1] >> double_[_c = _1, _val = _a];      // crashes

                start     %= enclosing;

                BOOST_SPIRIT_DEBUG_NODE(start);
        }

private:
        qi::rule<It, bool(),   Skipper>                  start;
        qi::rule<It, bool(),   Skipper>                  condition;
        qi::rule<It, bool(), qi::locals<bool, unsigned int, double, std::string>,  Skipper> enclosing;
        qi::symbols<char, unsigned int>                  cmp_operators;
};

bool doParse(const std::string& input)
{
        typedef std::string::const_iterator It;

        std::string::const_iterator begin = input.begin();
        std::string::const_iterator end = input.end();

        parser<It, qi::space_type> p;
        bool data;

        try
        {
                bool ok = qi::phrase_parse(begin, end, p, qi::space, data);
                if (ok)
                {
                        std::cout << "parse success\n";
                        std::cout << "data: " << std::boolalpha << data << "\n";
                }
                else      std::cerr << "parse failed: '" << std::string(begin, end) << "'\n";

                if (begin!=end) std::cerr << "trailing unparsed: '" << std::string(begin, end) << "'\n";
                return ok;
        } catch(const qi::expectation_failure<It>& e)
        {
                std::string frag(e.first, e.last);
                std::cerr << e.what() << "'" << frag << "'\n";
        }

        return false;
}


int main()
{
        bool ok = doParse("2.0001 <= 2 1");
        ok      = doParse("2.0001 =< 2 2") && ok;
        ok      = doParse("2.0001 >= 2 3") && ok;
        ok      = doParse("2.0001 => 2 4") && ok;
        return ok? 0 : 255;
}