Regex Pattern Problem

[JavaRegexer]

Hallo,

ich möchte mich mal etwas näher mit den Java Pattern beschäftigen und habe mir ein kleines Beispiel
Programm geschrieben.
Nur habe ich hier schon ein Problem welches ich nicht verstehe.

Ich habe in einem String folgendes gespeichert:

menu ic_menu
{
	titel : "Information Center"
	label:	"Information Center"


	items
	{
		call personenkontoliste_pro_jahr,
		call personenkontoliste_pro_periode,
		goto	mehr_reports,
		goto	Azubi_reports,
		call personenkontosaldo,
		call ao_stammdatenreport,
		call notepad
	}


	buttons
	{
		fct1 $(hauptmenue) mainmen,
		fct2 $(verlassen) leave
	}

	entrycode
	{
		$(fk_mandant) = mand_nr();
	}
}

menu	Azubi_reports
{
	titel:	"Azubi Reports"
	label:	"Azubi Übungen"

	items
	{
		call uebneu,
		call uebruet,
		goto megaeat
	}
	buttons
	{
		fct1	$(hauptmenue)	mainmen,
		fct2	$(verlassen)	leave
	}
}


menu	megaeat
{
	titel:	"Essensverwaltung MegaPlus"
	label:	"Essensverwaltung MegaPlus"

	items
	{
		call megaeat_mitarb,
		call megaeat_bestell,
		call megaeat_print
	}
	buttons
	{
		fct1	$(hauptmenue)	mainmen,
		fct2	$(verlassen)	leave
	}
}

menu	mehr_reports
{
	titel:	"Noch mehr Reports"
	label:	"Viele Weitere"

	items
	{
		call uebneu,
		call uebruet
	}
	buttons
	{
		fct1	$(hauptmenue)	mainmen,
		fct2	$(verlassen)	leave
	}
}


ACTION personenkontoliste_pro_jahr "Personenkontoliste pro Jahr Mandant: $(fk_mandant)"
	exec "Viewer.exe" "EXTERNAL#TemplateName=Reports/K/PersonenkontenInformation/Personenkontoliste pro Jahr.xml\; Provider=Oracle Provider for OLE DB\; Server=$(ic_server)\; Database=$(ic_db)$(fk_mandant)\; Userid=$(ic_id)$(fk_mandant); Language=1033\;";

ACTION personenkontoliste_pro_periode "Personenkontoliste pro Periode"
	exec "Viewer.exe" "EXTERNAL#TemplateName=Reports/K/PersonenkontenInformation/Personenkontoliste pro Periode.xml\; Provider=Oracle Provider for OLE DB\; Server=$(ic_server)\; Database=$(ic_db)$(fk_mandant)\; Userid=$(ic_id)$(fk_mandant); Language=1033\;";

ACTION personenkontosaldo "Personenkontosaldo"
	exec "Viewer.exe" "EXTERNAL#TemplateName=Reports/K/PersonenkontenInformation/Personenkontosaldo.xml\; Provider=Oracle Provider for OLE DB\; Server=$(ic_server)\; Database=$(ic_db)$(fk_mandant)\; Userid=$(ic_id)$(fk_mandant); Language=1033\;";

ACTION ao_stammdatenreport "AO Stammdatenreport"
	exec "Viewer.exe" "EXTERNAL#TemplateName=Reports/K/AO/Stammdatenreport.xml\; Provider=Oracle Provider for OLE DB\; Server=$(ic_server)\; Database=$(ic_db)$(fk_mandant)\; Userid=$(ic_id)$(fk_mandant); Language=1033\;";

ACTION notepad "Notepad" exec "notepad.exe" "EXTERNAL#$(fk_mandant)";

ACTION uebneu "Uebung vom Neuhäusel: $(fk_mandant)"
	exec "Viewer.exe" "EXTERNAL#TemplateName=Reports/K/PersonenkontenInformation/Personenkontoliste pro Jahr.xml\; Provider=Oracle Provider for OLE DB\; Server=$(ic_server)\; Database=$(ic_db)$(fk_mandant)\; Userid=$(ic_id)$(fk_mandant); Language=1033\;";

Nun möchte ich die menu-Blöcke matchen, inklusiver deren Inhalt.
Mein Pattern dazu sieht wie folgt aus:

Pattern p = Pattern.compile("menu\\s+\\w+\\s+[\\{](.*)[\\}]");

Doch so bekomme ich leider nichts raus.
Wenn ich ihn aber ändere zu :

Pattern p = Pattern.compile("menu\\s+\\w+\\s+[\\{](.*)");

liefert er mir immer den Anfang der menu-Blöcke und geht nicht bis zur schließenden } Klammer.
Also:

menu ic_menu
{
menu	Azubi_reports
{
menu	megaeat
{
menu	mehr_reports
{

kommt heraus.

Ach so, die Ausgabe erzeuge ich per

              Matcher m = p.matcher(mytext);
			
			while ( m.find() ) {
				System.out.println (m.group());
			}

Was mache ich falsch?

 

[SlaterB]

bei mir wird die komplette Datei in einem find() gefunden und ausgegeben,
was soll denn die Bedingung sein? warum glaubst du, dass das (.*) genau bis zum nächsten menue laufen wird?

nix da, du musst das Ende schon genau angeben, am einfachsten mit XML:
<menue>
...
</menue>

-----------

hier noch ein Pattern, über das du rätseln kannst:
Pattern p = Pattern.compile("menu\\s+\\w+\\s+[{]([^{]*[{][^{}]*[}][^}]*)*[}]");

Tipp: \\{ in eckigen Klammern [] kann auch direkt als { geschrieben werden,
geht bei den meisten Sonderzeichen,

wenn kein * oder ähnliches hinten dran kommt, dann kannst du dir []auch sparen, bei mir also z.B.

Pattern p = Pattern.compile("menu\\s+\\w+\\s+\\{([^{]*\\{[^{}]*\\}[^}]*)*\\}");

 

[kama]

Hallo,

zuerst einmal hier ein kleiner Test-Case zum Probieren.
Ich würde Dir raten das Ganze zuerst einmal kleiner anzufangen.

public class PatternTest extends TestCase {

	public static final String search = "menu Anton { Hallo; }\nmenu Egon{ Hallo; }\nmenu Hugo { Hallo; }"; 

	public void testMatch () {
		Pattern p = Pattern.compile("menu\\s+(\\w+)\\s*\\{(.*)\\}"); 
		Matcher m = p.matcher(search);
		while ( m.find() ) {
			for(int i=0; i<=m.groupCount(); i++) {
				System.out.println("[" + i + "]=" + m.group(i));
			}
			System.out.println("--------------");
		}
	}
}

und zum anderen würde ich mir hier schon ernsthaft überlegen, schon ein Werkzeug wie ANTLR einzusetzten anstatt mit RegEx zu arbeiten.

Aber auf jeden fall immer in kleinen Schritten anfangen und TDD ....


MfG
Karl Heinz Marbaise

 

[Leroy42]

Interessant:

menu   megaeat 
{ 
   titel:   "Essensverwaltung MegaPlus" 
   label:   "Essensverwaltung MegaPlus" 

   items 
   { 
      call megaeat_mitarb, 
      call megaeat_bestell, 
      call megaeat_print 
   } 
   buttons 
   { 
      fct1   $(hauptmenue)   mainmen, 
      fct2   $(verlassen)   leave 
   } 
}

Was soll das denn überhaupt für eine Sprache sein? :shock:

 

[JavaRegexer]

Hallo,

vielen Dank für eure Antworten.
@SlaterB

Danke dein Ausdruck funktioniert fast perfekt, er vergisst nur die allerletzte beim letzten Menu schließende } Klammer, aber ich denke das bekomme ich noch hin.
Ich versuch mal zu erklären, wie ich deinen Ausdruck verstanden habe, vielleicht finde ich dann ja raus was noch ergänzt werden muss.
Also

menu\\s+\\w+\\s+[{]

ist klar menu bis erste öffnende { Klammer.

[^{]*

Beliebig viele Zeilen ohne { am Anfang,

[{]

gefolgt von einer öffnenden { Klammer

[^{}]*

gefolgt von beliebig vielen Zeilen ohne jegliche Klammer am Anfang

[}]

eine schließende } Klammer

[^}]*

gefolgt von beliebig vielen Zeilen ohne schließende Klammer am Anfang.
Dies wären die einzelnen Blöcke wie Buttons, items etc.

Da das Ganz in ()* geklammert war, kann dieses Muster beliebig oft auftreten.

[}]

Die ansich abschließende } Klammer zum Menu, die Leider nicht funzt.

Ich habs auch schon ohne

[^}]*

versucht, leider ohne erfolg.

 

[SlaterB]

tja, bei mir gehts, aber ist müßig darüber zu reden,
ohne zu wissen, wie dein String tatsächlich vorliegt,
als Datei/ String, wie Eingelsen, Zeilenumbrüche oder nicht, ..

zwei Tipps:
1. siehe kama, klein anfangen,
2. vollständiges Programm posten,
auch wenn es mühselig ist, die 100 Zeilen direkt als Java-String zusammenzubauen,
ohne vollständiges Programm kann man keine Ergebnisse vergleichen,
wenn du Tipp 1. verfolgst, dann wird das auch leichter, da weniger zu tippen

 

[JavaRegexer]

Ah ok, das könnte es sein.
Ich lese den Inhalt aus einer Datei unter Linux ein.
Das mache ich wie folgt:

StringBuffer store = new StringBuffer();
	
	
	Pattern menublock = Pattern.compile("menu\\s+\\w+\\s+[{]([^{]*[{][^{}]*[}]*)*[}]", Pattern.UNIX_LINES | Pattern.MULTILINE );
		
	
	public MenueParser() {
		// TODO Auto-generated constructor stub
		
		try {
			Menuedatei = new File("ic.men"); 
			fr = new FileReader(Menuedatei);
			br = new BufferedReader(fr);
			
			zeile = br.readLine();
			while(zeile != null){
	             store.append(zeile+"\r\n");
	             zeile = br.readLine();
	        }
	        br.close();
	
			Matcher m = menublock.matcher(store.toString());
			
			while ( m.find() ) {
				System.out.println (m.group());
			}
			
		} 
		catch (FileNotFoundException fnfe) { 
		      System.out.println("Habe gefangen: "+fnfe); 
	    } 
	    catch (IOException ioe) { 
	      System.out.println("Habe gefangen: "+ioe); 
	    }

Vielleicht ein Problem mit den Zeilenumbrüchen?

 

[SlaterB]

da ich keine Linux habe, werde ich mich dazu nicht weiter äußern

 

[JavaRegexer]

Hmm schade.
Darf ich die fragen wie du es erfolgreich testen konntest?
Also wie hast du die Datei nachgestellt?

 

[SlaterB]

public class Test
{

    public static void main(String[] args)
        throws Exception
    {
        File f = new File("temp.txt");
        BufferedReader r = new BufferedReader(new FileReader(f));
        StringBuilder b = new StringBuilder();
        String line = null;
        while ((line = r.readLine()) != null)
        {
            b.append(line);
        }
        Pattern p = Pattern.compile("(menu\\s+\\w+\\s+[{]([^{]*\\{[^{}]*\\}[^}]*)*[}])");
        Matcher m = p.matcher(b.toString());

        while (m.find())
        {
            System.out.println("f: " + m.group());
        }


    }
}

 

[JavaRegexer]

Ok ich versuchs mal damit.
Wie hast du denn die temp.txt erstellt?
Per Copy&Paste hier aus dem Forum?

 

[SlaterB]

genau

 

[JavaRegexer]

Ok, ich glaube ich habe für heute genug :lol:

Ich musste deinen Code an 1 Stelle ändern um überhaupt eine Ausgabe zu bekommen

while ((line = r.readLine()) != null)
	        {
	            b.append(line[b]+"\n"[/b]);
	        }
	                
	        
//Hier wieder das [^}] raus, damit ich die schließenden KLammer bekomme
Pattern p = Pattern.compile("(menu\\s+\\w+\\s+[{]([^{]*\\{[^{}]*[}]*)*[}])" );

Soweit, so schlecht. Die letzte schließende KLammer kommt einfach nicht... :x

Aber ich danke dir für deine Mühen