std::isspace oder to_int_type crasht mit SIGSEGV

Sone

Hi!

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

Code an mi na

Hast auch was kompilierbares.

Sone

out schrieb:

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...