Mein Programm stürzt mit einem Segfault ab. Er scheint aus std::isspace zu kommen, könnte aber auch von to_int_type stammen:

template <typename CharT>
        inline bool
        isspace_(CharT c)
        {
            using namespace std;
            return isspace(to_int_type(c)) ? true : false; ///Hier ist der Segfault im Debugger
        }

Im Debugger sehe ich, dass isspace_ mit 65 ('A') als Funktionsparameter aufgerufen wird. Was zum Teufel kann da schiefgehen??

MfG

Hast auch was kompilierbares.

nope.
Das ist ja mit Boost, also, falls du das kompilieren kannst:

#define BOOST_LCAST_NO_WCHAR_T
#include <boost/spirit.hpp>
#include <locale>

#include <boost/spirit/home/support.hpp>
#include <boost/spirit/include/qi_lit.hpp>

using namespace boost::spirit;

struct programmGrammar : public grammar<programmGrammar>
{
        template <typename Scanner>
        struct definition
        {
                rule<Scanner> logic_and,
                              logic_or,
                              logic_not,
                              binary_logic_op,
                              unary_logic_op;

                rule<Scanner> character,
                              index,
                              boolean,

                              variable,
                              input,
                              indexed_variable,

                              expression,

                              binary_expr,
                              unary_expr,
                              braced_expr,

                              generalized_expr,

                              assignment,

                              programm;

                definition(const programmGrammar&)
                {
                        programm = "FUNCTION" >> input >> *assignment >> "RETURN" >> expression;

                        expression = braced_expr
                                   | boolean
                                   | generalized_expr
                                   | indexed_variable;

                        boolean = ch_p('T') | ch_p('F');

                        generalized_expr =  unary_expr | binary_expr;

                        binary_expr = expression >> binary_logic_op >> expression;
                        unary_expr = unary_logic_op >> expression;
                        braced_expr = ch_p('(') >> expression >> ch_p(')');

                        logic_and = str_p("AND");
                        logic_or = str_p("OR");
                        logic_not = str_p("NOT");

                        binary_logic_op = logic_and | logic_or;
                        unary_logic_op = logic_not;

                        character = range_p('A', 'Z');
                        index = range_p('0', '7');

                        variable = *character;
                        input = variable;

                        indexed_variable = variable >> index;

                        assignment = variable >> ":=" >> expression;
                }

                const boost::spirit::rule<Scanner> &start()
                {
                        return expression;
                }
        };
};

void ensureUpperCase(std::string& str)
{
        for(auto iter = str.begin();iter != str.end();++iter)
                *iter = std::toupper(*iter);
}

bool valid(std::string str)
{
        ensureUpperCase(str);
        static programmGrammar PG;
        return parse(str.c_str(), PG, boost::spirit::space_p).full;
}

int main()
{
        for(;;)
        {
                std::string str;
                std::getline(std::cin, str);
                std::cout << (valid(str)? "valid" : "invalid" ) << "!\n";
        }
}

Ich hab es so weit aufgeteilt, weil das irgendwie geholfen hat...