Regex für (+ 2 3)

[f145h]

Servus Leute,

ich versuche grad nen Interpreter für Scheme zu schreiben und da muss ich erstmal die Eingabe auf Syntax überprüfen.
also folgendes soll erkannt werde (+ 2 3) oder (- 2 3) aber auch (expt 2 3)
hab dafür ne regex geschrieben:

		Pattern p = Pattern.compile("\\([\\+ \\- \\* / = ]\\s[1-9]*\\s[1-9]*\\)");

dies erkennt aller dings nur + - * usw.. aber nicht "expt". und das ist auch mein Problem. wie kann ich in eckigeklammer ein string einfügen? also sowas funktioniert ja nicht : [\\+ \\- \\* / = expt ], da hier "expt" nicht als wort sondern als einzelne buchstaben (mit | verknüpft) erkannt wird. Ich kann dafür noch eine regax schreiben, aber das wäre ein umweg und vielleicht hat einer von euch ne idee wie ich das doch noch in [] reinpacken kann.

und meine zweite Frage wäre: kann man auch sowas (+ (- 2 3) (/ 2 (+ 2 3))) mit ner regex abdecken oder braucht man dafür nen kellerautomaten( also stack und so )?

hoffe ich hab mich einigermaßen verständlich ausgedrückt.

vielen Dank im Vorraus

 

[SlaterB]

(+|-|expt)
ohne eckige Klammen

und einen vollständigen Parser bekommt man mit regulären Ausdrücken nicht hin oder wenn nur extrem umständlich
(oberste Verschachtelung erkennen, für Teilausdrücke neu auswerten)

 

[Ariol]

Versuch mal das hier (ungetestet)

Pattern p = Pattern.compile("\\([\\+|\\-|expt]\\s[1-9]+\\s[1-9]+\\)");

Was die 2. Frage angeht: Ich denke mit Regex wird das ziemlich schwer...Keller klingt einfacher

 

[f145h]

Vielen Dank *schäm*

also gibt es doch keine möglichkeit ein wort in ne eckige klammer reinzupacken.

[\\+|\\-|expt]

wird nicht gehen, weil der "expt" nicht als ganzes wort sieht.

 

[Ariol]

Stimmt, du musst auch runde Klammern verwenden:

Pattern p = Pattern.compile("\\((\\+|\\-|\\*|\\/|expt)\\s[1-9]+\\s[1-9]+\\)");

 

[Dissi]

Ich hasse Scheme, 1. Semester Infostudium gehabt. Multiparadigmatische Wunderwaffe ^^

 

[ModellbahnerTT]

Lisp ist nicht regulär, du brauchst also gar nich erst versuchen anzufangen einen RegEx für die Sprache zu bauen

 

[f145h]

Hey leute,

hab jetzt ein zweites Problem und zwar: der benutzer kann beliebig viele zahlen eingeben und ich muss diese Zahlen abspeichern aber damit ich die zahlen richtig abspeichern kann <b>muss ich erstmal feststellen, ob die eingegebene Zahl ein Integer , ein Double, ne Komplexe Zahl usw.... ist.Gibt es dafür ne bestimmte Methode oder so?<\b> Hab lang probiert bzw. gesucht( vielleicht weis ich auch nicht wonach ich genau suchen soll ) finde aber keine Lösung dafür gefunden.

 

[SlaterB]

schwer vorzustellen was es für einen Unterschied macht, wie du es speicherst,
geh doch einfach immer vom vollständigen aus, speichere alles als Komplexe Zahl mit Komma-Zahlen, also 1.0 i +1.0 oder wie das war

das Parsen ist natürlich nicht leicht, nach dem + suchen, nach dem i usw.
meinst du vielleicht das, wie man dafür Regeln findet?
Schritt für Schritt herantasten, und dann doch lieber wieder einfach anfangen:
erstmal nur einfache Zahlen aus Ziffern parsen: 34889, kein Komma, kein +-, kein i usw.,
wenn das klappt nach und nach Varianten hinzufügen und immer darauf achten, dass die einfachen Eingaben auch akzeptiert werden,

wenn du ein konkretes Problem hast a la
'bei Eingabe xy funktioniert folgender 20zeiliger Code nicht mehr obwohl das eigentlich in Zeile 17 behandelt werden soll'
kann man dann weiterhelfen

 

[f145h]

ok lassen wir fürs erste die komplexen zahlen weg( da werde ich mich wahrschein mit regex herantasten).

nehmen wir ich lese eine "3" oder ne "3.0" von der console. Um damit zu rechnen muss ich erstmal wissen ob die eingelesene Zahl eine ganze Zahl ist oder ein Kommazahl. Ich hab mir gedacht, ich fange ganz von unten an und versuche die zahl als Integer zu parsen, falls ne Exception kommt, dann versuche die zahl als double zu parsen usw...
Aber das ganze geht doch bestimmt auch einfacher oder nicht?
wenn ich erstmal weis, wie ich das machen muss, wird das ganze zu coden kein problem mehr sein

 

[SlaterB]

einfacher ist es, gleich als double zu parsen und zu ignorieren, ob nun Nachkommastellen da sind oder nicht,

wenn es doch einen Unterschied macht, dann den Double auf int casten und schauen, ob die Zahlen immer noch gleich sind
oder den String nach Punkt oder Komma durchsuchen,

ich sehe da kein fertiges Verfahren

 

[diggaa1984]

hm ich weiss net ob das so gross was hilft, aber ich hab für mein grammatik-editor INT und FLOAT als wildcards in den grammatiken erlaubt, das heisst ich definiere nicht ne Zahl mittels:

INT = Digit | INT Digit
Digit = 0 | 1 | ... | 9

sonder der Nutzer kann das einfach INT und FLOAT als Nichtterminal nutzen.
Im Programm muss ich natürlich erkennen ob ich nun nen Integer oder nen FLOAT vor mir hab, das mache ich per RegExp.

float: [code](\\d+\\.\\d+([eE]?[-+]?\\d+)?)

markant der . den gibts bei Int einfach nicht[/CODE]

Dabei ziehe ich erst alle FLOATs raus, da diese von der Struktur her komplexer sind, und alles was dann noch übrig bleibt muss ein INT sein. Also erst Float raussuchen dann die Ints. Bei dir mit den komplexen Zahlen müsste es dann doch auch gehen, erst die komplexen Zahlen zu filtern (dabei muss ja minimum n i in der Zahl erscheinen) .. damit hast schonmal ne klare Abgrenzung zu den Floats .. sollte also nix schief gehen. Danach haste nur noch Floats und Ints über.

Das müsstest aber eben vorm eigentlich verarbeiten für den kompletten String entscheiden, die Frage ist wie du das verarbeitest.

 

[Ariol]

Wir haben bei unserem "Compilerbau"-Projekt int und float so definiert:

INT_CONST 				= [0-9]+
FLOAT_CONST 			= [0-9]+\.[0-9]+[E|e][0-9]+|[0-9]*\.[0-9]+[df]*|[0-9]+[df]+

 

[diggaa1984]

was ist denn 123.12345ffffffffffffffffffffffff ? (vorletzte alternative)

aso oder war das ein Stern aus der theoretischen informatik? habe den grad als stern aus java-regXp aufgefasst, da wäre das ja [0,inifitiy)

 

[Ariol]

Uiiii, stimmt...
Mir fällt grad auf dass da noch mehr Fehler drin sind....
Und auch das es garnicht die Version ist, die wir abgegeben haben...Sorry

 

[f145h]

also ich habe jetzt 3 methoden geschrieben.( für Ganzezahlen(Integer),Kommezahlen(Float ) und Komplexe Zahlen) aber ich glaube diese Methoden werden sich noch im Laufe des Projekts ändern, da ich jetzt erstmal wirklich nur ganz einfache Zahlen( wie z.B 1212,12.12 oder 12+12i) abdecke. Falls jemand bessere regex hat bzw. nen Fehler entdeckt, sagt bitte bescheid.

/**
	 * Pruefe ob ne Ganzezahl
	 * @param a
	 * @return
	 */
	public static boolean isAInt(String number){
		
		Pattern p = Pattern.compile("(\\+|\\-)?\\d+");		
		Matcher m = p.matcher(number);
		boolean match = m.matches();
		
		
		return match;
		
	}
	/**
	 * Pruefe ob ne Kommazahl
	 * @param a
	 * @return
	 */
	public static boolean isAFloat(String number){
		
		Pattern p = Pattern.compile("(\\+|\\-)?\\d+\\.\\d+");		
		Matcher m = p.matcher(number);
		boolean match = m.matches();
		
		return match;
		
	}
	/**
	 * Pruefe ob eine KomplexeZahle
	 * @param a
	 * @return
	 */
	public static boolean isAComplexNumber(String number){
		
		Pattern p = Pattern.compile("\\d+\\+\\d*i");		
		Matcher m = p.matcher(number);
		boolean match = m.matches();
		
		return match;
		
	}

 

[diggaa1984]

(\\+|\\-)? kannst auch als [+-]? schreiben .. is lesbarer find ich ^^

 

[Ark]

Vielleicht eher so:
[java=37] Pattern p = Pattern.compile("[+-]?\\d+\\.\\d+[+-]?\\d+\\.\\d+i");[/code]
Aber was machst du mit Ausdrücken wie [c]12+(4*f)i[/c]? Ich glaube, du solltest dich vom Versuch verabschieden, das alles in Typ 3 pressen zu wollen.

Ark

 

[f145h]

@Ark also so 12+(4*f)i ist in Scheme glaub ich gar nicht erlaubt ( hoffe ich zumindest , sowie ich Scheme bis jetzt verstanden habe, taucht immer ein Operator nach der klammer und dann die argumente,deshalb ist es auch möglich dafür einen regulären ausdruck anzugeben. vielleicht liege ich auch falsch damit, da ich wirklich noch ein änfänger bin, was Scheme angeht.
ansonten danke für deinen Hinweis mit den Kommazahlen

 

[Ark]

Ich habe mich mal kurz schlau gemacht, was die Syntax von Scheme angeht, und speziell diese Ausdrücke scheinen in eine Typ-2-Grammatik zu gehören, ergo reichen Typ-3-Grammatiken (also reguläre Ausdrücke) nicht aus. Das ganze hat übrigens nichts mit der Position der einzelnen Operanden und Operatoren zu tun, sondern einfach mit der Tatsache, dass (wie die Umgangssprache sagt ) endliche Automaten nicht zählen können.

Ark