✔ [C] Problem mit Scannergenerator Flex und Regel

[Razorhawk]

Ich bin dabei ein Scanner mit Flex für eine Sprache zu erstellen aus einer Datei die ich auch mit dazugebe.
Fast alles funktioniert soweit, jedoch möchte ich, dass alle nichterlaubten Zeichen das Programm abbrechen mit exit(-1).

die Regel lautet [^a-zA-Z0-9] {....}
aber es funktioniert nicht so wie ich will.
Nach dieser Regel müssten alle Zeichen als nicht erlaubt gelten, welche 1. nicht explizit als Regel der Form "x-irgendwas" {} erkannt werden oder keine Zahlen / Buchstaben sind (IDs halt)
Aber letztendlich sagt er mir dennoch beim scannen, dass "not" kein erlaubtes Zeichen ist, obwohl dieser Begriff doch durch die Regel

{buchstabe}+({buchstabe}|{ziffer})* { yylval.string = strdup(yytext); return ID; }

welche schon vorher steht abgegriffen werden müsste!
Tut es aber nicht, weiß einer, was ich falsch machen könnte?

Ich weiß, dass hier wahrscheinlich nicht jeder drauf anworten kann, da das sehr speziell ist, aber diejenigen die Ahnung von haben würden mir sehr helfen

So nun zu der lexic-datei und danach die zu scannende Sprache c0 :

%option noyywrap
%option yylineno
%option nounput

%{
#include "minako.h"
#include "string.h"
%}

%x COMMENT
%x SLCOMMENT

ziffer             [[:digit:]]
buchstabe          [[:alpha:]]|_
whitespace         [ \n\t]
integer            ({ziffer})+
float              ({integer}"."{integer})|("."{integer})

%%

{whitespace}+                      { }




"&&"                               { return AND;}
"||"                               { return OR;}
"=="                               { return EQ;}
"!="                               { return NEQ;}
"<="                               { return LEQ;}
">="                               { return GEQ;}
"<"                                { return LSS;}
">"                                { return GRT;}

"bool"                             { return KW_BOOLEAN;}
"do"                               { return KW_DO;}
"else"                             { return KW_ELSE;}
"float"                            { return KW_FLOAT;}
"for"                              { return KW_FOR;}
"if"                               { return KW_IF;}
"int"                              { return KW_INT;}
"printf"                           { return KW_PRINTF;}
"return"                           { return KW_RETURN;}
"void"                             { return KW_VOID;}
"while"                            { return KW_WHILE;}


[-+]?{float}([eE][-+]?{integer})?|{integer}[eE][-+]?{integer}         {  yylval.floatValue = (float) strtod(yytext, NULL);
									 return CONST_FLOAT;}

{integer}                          {  yylval.intValue = atoi(yytext);
				      return CONST_INT;}



"true"|"false"                     { return CONST_BOOLEAN;}



"//"                               { BEGIN(SLCOMMENT); }

<SLCOMMENT>"\n"                    { BEGIN(INITIAL);}

<SLCOMMENT>.|"\n"                    { }



{buchstabe}+({buchstabe}|{ziffer})* { yylval.string = strdup(yytext); return ID; }






"/*"                               { BEGIN(COMMENT); }

<COMMENT><<EOF>>                   { fprintf(stderr,"ERROR: Unerwartetes Dateiende, Kommentar (/* ... */) wurde nicht geschlossen in Zeile %d \n",yylineno);
					exit(-1);
					}

<COMMENT>"*/"                      { BEGIN(INITIAL); }

<COMMENT>.|"\n"                    { }



.                                  { return *yytext; }

[^a-zA-Z0-9]                     { fprintf(stderr,"ERROR: Nicht erlaubtes Zeichen \"  \" in Zeile %d \n",yylineno);
							exit(-1);
							}




<<EOF>>                            {return EOF;}


%%

/* Ueberprueft deMorgans Law */

// Die erwartete Ausgabe steht am Ende dieser Datei

bool not(bool b) {
	if (b == true) return false;
	else return true;
}

bool morgan11(bool a, bool b) {
	return not(a || b);
}
bool morgan12(bool a, bool b) {
	return not(a) && not(b);
}

bool morgan21(bool a, bool b) {
	return not(a && b);
}
bool morgan22(bool a, bool b) {
	return not(a) || not(b);
}

void main() {
	bool a = true;
	bool b = true;
	int i=0;

	do {
		do {

			printf(i);
			
			printf(morgan11(a,b));
			printf(morgan12(a,b));
			printf(morgan21(a,b));
			printf(morgan22(a,b));
			
			i = i+1;
			b = not(b);
		} while (b != true);
		a = not(a);
	} while(a != true);

}

/* Erwartete Ausgabe:
0
false
false
false
false
1
false
false
true
true
2
false
false
true
true
3
true
true
true
true
*/

 

[deepthroat]

Hi.

Also wenn ich das richtig sehe sollte deine Ausschlußregel für unerlaubte Zeichen sowieso nie ausgeführt werden, da du ja davor bereits direkt davor eine Regel geschrieben hast die jedes Zeichen matched.

Wenn ich die Regeln bei mir so umsortiere bekomme ich wie das erwartete Ergebnis.

Übrigens kannst du die Regel für unerlaubte Zeichen einfach als letzte Regel mit dem . als Alles-Matcher schreiben - so wird jedes Zeichen welches vorher nicht gematcht wurde als unerlaubt zurückgewiesen.

Gruß

 

[Razorhawk]

Danke vielmals.
Hab das dann uach mmitbekommen gestern Nachmittag, dass das mit der .-Regel besser geht alles nicht gematchte auszuschließen!