# zusammengehörige if-else-endif erkennen



## magic_halli (8. Februar 2008)

Hallo.

Ich habe ein Textfile mit darin enthaltenen if-Anweisungen (auch verschachtelt möglich), z.B:

```
IF <Bedingung>
   textzeile1
   if <Bedingung>
      textzeile2
      if <Bedingung>
         textzeile3
      endif
   else
      textzeile4
   endif
   textzeile5
ELSE
   textzeile6
   if <Bedingung>
      textzeile7
   else
      textzeile8
   endif
   textzeile9
ENDIF
```
Mein Problem ist, wie kann ich erkennen, welches ENDIF zu welchem IF gehört und welches ELSE, wenn vorhanden, zu welchem IF/ENDIF gehört.
Mir fehlt hierfür ganz einfach ein Lösungsansatz, wie man das ermitteln kann - selbst in Worten gesprochen komme ich irgendwie nicht drauf!   
Kann mir bitte jemand helfen! Ich will gar nicht mal Code haben, nein... ich brauche nur paar Ideen bzw. Tips, wie ich ermitteln kann, welche IF/ELSE/ENDIF zusammengehören, um das dann programmiertechnisch umzusetzen!

Danke und Gruß.


----------



## zerix (8. Februar 2008)

Hallo,

kannst du mal erklären, was du überhaupt machen möchtest. 

Sowas programmtechnisch zu erkennen ist nicht so das problem. Jedes else bzw endif gehört zu dem letzten "geöffneten" if. Sobald ein endif kommt, ist das letzte "geöffnete" if "geschlossen". Jedes dann folgende else oder endif, gehört dann zu dem davor geöffneten if. USW.


MFG

zEriX


----------



## Matze (8. Februar 2008)

Wenn das Texfile immer so schon eingerückt ist, dann kannst du so vorgehen, dass du sasgt alle Ifs und Els gehöhren zusammen wenn sie 2 Spaces eingerückt sind, und nicht von einer Zeile mit weniger Spaces unterbrochen werde.

Reicht das?


----------



## zerix (8. Februar 2008)

@Matze
Es gibt dann aber Probleme sobald keine Einrückungen vorhanden sind. 

MFG

zEriX


----------



## Matze (8. Februar 2008)

Matze from HwI hat gesagt.:


> Wenn das Texfile immer so schon eingerückt ist, dann ...


Setzte ich natürlich voraus.

Gegenfrage, was ist wenn ein ENDIF fehlt...^^


----------



## zerix (8. Februar 2008)

Dann stimmt die Syntax ja nicht. 

MFG

zEriX


----------



## Matze (8. Februar 2008)

Wieso? Erlich gesagt habe ich in Java noch nie ein ENDIF verwendet und es ging immer gut. Oder hat da jemand diesen Thread in das falsche Forum geschrieben?


----------



## zerix (8. Februar 2008)

Ich schätze mal, dass er den Code da mit Java einlesen möchte und dann ist es egal, welche Sprache es ist. Es gibt mehrere Sprachen die ein ENDIF haben.

MFG

zEriX


----------



## Matze (8. Februar 2008)

Hmm, also in dem Fall würde ich das File zuerst darauf überprüfen, ob es ein ENDIF hat und dann zerix Methode anwenden.


----------



## zerix (8. Februar 2008)

@Matze
Das funktioniert so nicht. Man geht von oben nach unten. Man braucht ja kein endif, wenn kein if vorhanden ist. Dann kann es immer noch sein, dass vielleicht ein ENDIF zuviel ist. Dann ist auch die Syntax falsch. Es könnten auch mehrere If-Anweisungen sein und zu wenig endifs, dann stimmt es ja auch nicht.

MFG

zEriX


----------



## magic_halli (8. Februar 2008)

1. Das File wird aus einem techn.Zeichenprogramm heraus generiert und ist IMMER syntaktisch korrekt in bezug auf IF-ELSE-ENDIF-Blöcke! Das ist schonmal die eine Gegebenheit.
2. Es existieren KEINE Einrückungen der Syntax. Jede Zeile beginnt am Zeilenanfang.

Ich möchte das File mit Java zeilenweise durchgehen (das funktioniert bereits) und je nachdem, ob ein IF true oder false ist und ob eventuell dazu noch ein ELSE-Zweig existiert, die dazwischenliegenden Zeilen bearbeiten.
Das ganze soll natürlich so funktionieren, dass auch verschachtelte IF´s erkannt und darauf entsprechend reagiert werden kann.



> Wenn Du in einer Zeile ein "IF" findest kannst/musst Du davon ausgehen das es auch ein "ENDIF" dazu gibt. Verinfacht kannst Du erstmal eine Zählvariable nehmen und diese incrementieren. Sollte innerhalb des gefundenen "IF" wieder ein "IF" auftauchen, tust Du die Zählvariable wieder um eins hochzählen. Findest Du das erste "ENDIF" kannst/musst Du davon ausgehen das es sich hierbei um das "ENDIF" handelt welches zum 2. gefundenen "IF" gehört. Das nächste gefundene "ENDIF" gehört somit zum ersten gefundenen "IF".
> 
> Genauso kannst Du das mit einem "ELSE" oder "ELSEIF" machen.


Mh, sowas ähnliches hab ich schonmal versucht umzusetzen... kam aber nur Mist bei raus, da ich irgendwie völlig durcheinander kam.


----------



## zerix (8. Februar 2008)

Wie ich oben schon gesagt hab, else und endif gehören immer zum letzten "geöffneten" if.

Ich hoffe das hilft dir mal weiter.

MFG

zEriX


----------



## Matze (8. Februar 2008)

Auch wenns kompliziert erscheint ist in deinem Fall die Lösung von zerix sehr gut und variable.


----------



## magic_halli (8. Februar 2008)

> Wie ich oben schon gesagt hab, else und endif gehören immer zum letzten "geöffneten" if.


Das ist mir sprachlich völlig einleuchtend, nur programmiertechnisch bekomme ich das nicht in den Kopf... z.B.:
1. ich finde ein IF (Bedingung hierzu ist true)
2. ich finde paar Zeilen weiter wieder ein IF (Bedinung ist false)
3. ich finde ein ELSE (gehört zum false-IF) und die Zeilen danach werden bearbeitet
4. ich finde ENDIF (gehört zum false-IF)
5. ich finde ELSE (gehört zum true-IF) und alle Zeilen danach werden nicht berücksichtigt
6. ich finde ENDIF (gehört zum true-IF)
7. alle Zeilen ab hier werden einfach berücksichtigt, bis wieder ein IF kommt, dann geht die ganze Unterscheidung von neuem los

Diese Abfolge in Java umzusetzen beschäftigt mich ungemein und ich komme einfach nicht weiter. Ein Ansatz wäre erstmal, das File zeilenweise durchzugehen und jede Zeile auf IF/ELSE/ENDIF zu prüfen:

```
boolean ifcheck;      //Variable, ob IF-Bedingung true oder false ist
BufferedReader buff = new BufferedReader(new FileReader(path + "myTextfile.txt"));
//jede Zeile durchgehen
while ( (line = buff.readLine()) != null) {
   if( line.startsWith("IF") || line.startsWith("if") ){
      //prüfen, ob IF-Bedingung true oder false ist (funktioniert bereits!)
      ifcheck = checkIF(line);   //checkIF(line) gibt true oder false zurück
      //und nun?

   }else if( line.startsWith("ELSE") || line.startsWith("else") ){
      //was nun hier tun?
   
   }else if( line.startsWith("ENDIF") || line.startsWith("endif") ){
      //was nun hier tun?
   
   }
}
```
Ich hab zwar diesen Ansatz, aber ich hänge auch hier fest - ich weiß nicht recht, wie nun weiter.


----------



## Matze (8. Februar 2008)

Ich würde das nicht mit einem boolschen Wert machen. FÜhre lieber einen Index, dann bist du Variabler und ist auch einfacher zu verstehen.

Was nun hier... Was willst du denn überhaupt machen?


----------



## Anime-Otaku (8. Februar 2008)

magic_halli hat gesagt.:


> Ich möchte das File mit Java zeilenweise durchgehen (das funktioniert bereits) und je nachdem, ob ein IF true oder false ist und ob eventuell dazu noch ein ELSE-Zweig existiert, die dazwischenliegenden Zeilen bearbeiten.
> Das ganze soll natürlich so funktionieren, dass auch verschachtelte IF´s erkannt und darauf entsprechend reagiert werden kann.


----------



## Matze (8. Februar 2008)

Anime-Otaku hat gesagt.:


>



Jetzt sag mir doch bitte, was du denkst was genau er mit bearbeiten meint


----------



## magic_halli (8. Februar 2008)

> Ich würde das nicht mit einem boolschen Wert machen. FÜhre lieber einen Index, dann bist du Variabler und ist auch einfacher zu verstehen.
> 
> Was nun hier... Was willst du denn überhaupt machen?


Den boolschen Wert habe ich erstmal pauschal, je nachdem ob IF gleich true oder false ist, gesetzt.
Ich kann ja auch einen Index mitführen... Index aber für was - für jedes gefundene IF/ELSE/ENDIF einen extra counter? 
Wie soll ich mit dem Index dann weiterverfahren, um zugehörige IF/ELSE/ENDIF zu erkennen?

Ich will im Endeffekt die Zeilen aus dem Textfile in ein neues Textfile speichern, sodass in dem neuen File nur noch die Zeilen drinstehen, die durch die Berücksichtigung von IF/ELSE/ENDIF übrig bleiben (mag vielleicht unsinnig erscheinen - ist aber Basis für andere Sachen)!


----------



## deepthroat (11. Februar 2008)

Hi.

Du müßtest dir in einem Stack die aktuellen Werte für die Bedingungen speichern, da du grundsätzlich von einem verschachtelten IF wieder ins übergeordnete IF/ELSEIF kommst und dort wissen mußt, ob die Bedingung war ist oder nicht.

Alg:

wenn Zeile == IF dann speichere Wert von Bedingung auf dem Stack.
bei ELSEIF Wert mit dem Top Stack vergleichen, falls FALSE, Wert vom Stack entfernen, neuen Wert von Bedingung drauf.
bei ELSE Wert des Stacks negieren.
bei ENDIF Wert vom Stack entfernen.

Gruß


----------



## magic_halli (12. Februar 2008)

> Du müßtest dir in einem Stack die aktuellen Werte für die Bedingungen speichern


Wie arbeite ich in Java mit einem Stack - habe ich noch nicht gemacht?! Gibts dafür ein allgemeines Vorgehen/Befehle/Methoden in Java?


----------



## deepthroat (12. Februar 2008)

magic_halli hat gesagt.:


> Wie arbeite ich in Java mit einem Stack - habe ich noch nicht gemacht?! Gibts dafür ein allgemeines Vorgehen/Befehle/Methoden in Java?


 Google: "Java stack"

Gruß


----------



## magic_halli (12. Februar 2008)

So, ich hab jetzt mal mit der Class Stack ein bischen herumgespielt und versucht, damit irgendwie eine Lösung meines IF-ELSE-ENDIF Problems zu erreichen. Leider komme ich auch hier nicht unbedingt voran... den Rechner habe ich nun schon 2mal zum Absturz gebracht. 



> wenn Zeile == IF dann speichere Wert von Bedingung auf dem Stack.
> bei ELSEIF Wert mit dem Top Stack vergleichen, falls FALSE, Wert vom Stack entfernen, neuen Wert von Bedingung drauf.
> bei ELSE Wert des Stacks negieren.
> bei ENDIF Wert vom Stack entfernen.


Dazu mal folgendes:

```
boolean ifcheck;      //Variable, ob IF-Bedingung true oder false ist
BufferedReader buff = new BufferedReader(new FileReader(path + "myTextfile.txt"));
Stack stack = new Stack();

//jede Zeile durchgehen
while ( (line = buff.readLine()) != null) {

   if( line.startsWith("IF") || line.startsWith("if") ){
      //prüfen, ob IF-Bedingung true oder false ist (funktioniert bereits!)
      ifcheck = checkIF(line);   //checkIF(line) gibt true oder false zurück
      //bei IF - true/false auf Stack
      if(ifcheck == true){
         stack.push( "true" );
      }else{
         stack.push( "false" );
      } 

   }else if( line.startsWith("ELSE") || line.startsWith("else") ){
      //bei ELSE Stack negieren
      if( stack.peek() == "true" ){
         stack.set(stack.size(), "false");
      }else{
         stack.set(stack.size(), "true");
      }

   }else if( line.startsWith("ENDIF") || line.startsWith("endif") ){
      //Wert vom Stack löschen
      try{
         stack.pop();
      }catch(EmptyStackException e){
         JOptionPane.showMessageDialog(null, "Stack ist leer!");
      }
   }

   //Auswahl der relevanten Zeilen
   if( stack.peek() == "true" ){
      JOptionPane.showMessageDialog(null, "oberstes Stackelement ist TRUE.      Stacksize="+stack.size() );
      strBuffer.append(line + "\n");
   }else if( stack.peek() == "false" ){
      JOptionPane.showMessageDialog(null, "oberstes Stackelement ist FALSE.      Stacksize="+stack.size() );
   }
}//while close 

//zur Überprüfung: neues Textfile nur mit relevanten Zeilen erstellen
//löscht evtl. exist. Textfile, bevor es neu erstellt wird
File f = new File(path + "myTextfile_NEU.txt");
if(f.exists()){
   f.delete();
}
BufferedWriter buff2 = new BufferedWriter(new FileWriter(path + "myTextfile_NEU.txt"));
buff2.write(strBuffer.toString());
buff2.close();
```
Ich bekomme hier eine Fehlermeldung "java.lang.ArrayIndexOutOfBoundsException: Array index out of range" für Zeile 21 angezeigt.
Außerdem bin ich mir gar nicht so sicher, ob das überhaupt so funktioniert mit dem ganzen true und false gesetze?!
Ach ja, mein (Ausgangs)Textfile sieht übrigens so aus:

```
IF 1==9
textzeile1
if 8==8
textzeile2
if 3<7
textzeile3
endif
else
textzeile4
endif
textzeile5
ELSE
textzeile6
if 4<6
textzeile7
else
textzeile8
endif
textzeile9
ENDIF
```
Je länger ich das alles anschaue, umso mehr bekomme ich´s im Kopf vor lauter true/false etc.!
Kann mir jemand zu meinem Code vielleicht paar Ansätze sagen, wie ich was eventuell verändern muß, damit ich nur die Zeilen (in Abhängikeit von IF=true/false) in myTextfile_NEU.txt geschrieben werden, die auch tatsächlich rein gehören!

Danke.


----------



## deepthroat (12. Februar 2008)

Hi.

Warum speicherst du denn String Objekte in dem Stack? Speichere doch einfach die booleschen Werte. Falls du Java >= 1.5 verwendest brauchst du durch das Auto-(Un)Boxing nicht mal die Boolean Klasse bemühen.


```
while ()  {
  line = line.toUpperCase();

  if( line.startsWith("IF")) {
    stack.push(checkIF(line));
  } else if (line.startsWith("ELSEIF")) { // Reihenfolge ist wichtig!
    if (!(bool)stack.peek()) {
      stack.pop();
      stack.push(checkIF(line));
    }
  } else if (line.startsWith("ELSE") {
    stack.push(!(bool)stack.pop());
  } else if (line.startsWith("ENDIF") {
    stack.pop();
  } else if (stack.empty() || (bool)stack.peek()) {
    // hier Zeile ausgeben
  }
}
```
Die Exception wird geworfen, weil du auf ein nicht-existentes Element zugreifst. Es sind n Element im Stack, numeriert von 0 bis (n-1). Es gibt also kein n-tes Element.

Gruß


----------



## deepthroat (12. Februar 2008)

Hi.

Ich hatte nicht bedacht, das die Entscheidung, ob man die Zeilen ausgeben kann, auch von der Bedingung des letzen if (und vorletzten if usw.) abhängen.

Hier mal ein Test in JavaScript (kannst du ja einfach übersetzen):

```
function checkIF(line) {
  var exp = line.substr(3);
  return eval(exp);
}

var text = ("IF 1==9;textzeile1;if 8==8;textzeile2;if 3<7;textzeile3;endif;else;" +
		   "textzeile4;endif;textzeile5;ELSE;textzeile6;if 4<6;textzeile7;else;textzeile8;" +
		   "endif;textzeile9;ENDIF").split(';');

var stack = new Array();
stack.push(true); // vor ersten if Ausgabe angeschaltet

stack.top = function () {
	return this[this.length-1];
}

for (var i = 0; i < text.length; ++i) {
  var line = text[i];

  if(/^IF/i.test(line)) {
    stack.push(stack.top() && checkIF(line));
  } else if (/^ELSEIF/i.test(line)) { // Reihenfolge ist wichtig!
    if (!stack.top()) {
      stack.pop();
      stack.push(stack.top() && checkIF(line));
    }
  } else if (/^ELSE/i.test(line)) {
    var b = stack.pop();
    stack.push(stack.top() && !b);
  } else if (/^ENDIF/i.test(line)) {
    stack.pop();
  } else if (stack.top()) {
    // Im if/else Zweig dessen Bedingung "TRUE" ist...
	document.writeln(line);
  }
}
```
Wenn du das im Browser ausführst, erhälst du als Ergebnis:

```
textzeile6
textzeile7
textzeile9
```
Gruß


----------



## Schnacki (12. Februar 2008)

Ich habe mal eine Frage dazu:

Bestehen die Abfragen  bei den IFs immer nur aus a==b oder sollen da irgendwann noch andere Operatoren hinzukommen (> < !=) ?

Falls ja, gibt es bessere Wege dies zu lösen. (Compilerbau, Rekursiver Abstieg...)

KAi


----------



## Stigma (12. Februar 2008)

Nein es sind auch anderre Operatoren möglich, selbst die Verschachtelung oder Aneinanderreihung ist möglich.


----------



## magic_halli (13. Februar 2008)

deepthroat hat gesagt.:


> Hi.
> 
> Ich hatte nicht bedacht, das die Entscheidung, ob man die Zeilen ausgeben kann, auch von der Bedingung des letzen if (und vorletzten if usw.) abhängen.
> 
> ...



Was macht 'stack.top()' - liefert mir das die Länge vom Stackspeicher?


----------



## deepthroat (13. Februar 2008)

magic_halli hat gesagt.:


> Was macht 'stack.top()' - liefert mir das die Länge vom Stackspeicher?


Was diese Funktion macht, steht doch da... Die Funktion ist doch dort implementiert. Die Länge würde das Attribut *length* liefern.

Die Funktion top() liefert den obersten Wert vom Stack - also bei der Java Stack Klasse das gleiche wie die Methode peek().

Gruß


----------



## magic_halli (13. Februar 2008)

> Die Funktion top() liefert den obersten Wert vom Stack - also bei der Java Stack Klasse das gleiche wie die Methode peek().


Ok, das habe ich mir dann auch so gedacht...
Das Stück Code:

```
if(/^IF/i.test(line)) {
   stack.push(stack.top() && checkIF(line));
}
```
... trägt im Falle von 'IF gefunden' in den Stack ein "true" bzw. "false" ein (was von der Funktion checkIF zurückgegeben wird) - richtig?!
Was ich aber dann nicht ganz verstehe:
Wenn stack.top() analog stack.peek() ist, wieso wird dann das oberste Element vom Stack gelesen (aber nicht wie durch pop() entfernt) und ein true/false angehängt?
Wieso nicht einfach '_stack.push(checkIF(line))_' oder '_stack.push("true")_' bzw. '_stack.push("false")_'?

Gruß


----------



## deepthroat (13. Februar 2008)

magic_halli hat gesagt.:


> Wieso nicht einfach '_stack.push(checkIF(line))_' oder '_stack.push("true")_' bzw. '_stack.push("false")_'?


Weil's dann nicht funktioniert. 

Bsp: 
	
	
	



```
IF 5 = 10
IF 5 = 5
PRINT 5
ENDIF
ELSE
PRINT 9
ENDIF
```
Wenn dieser Code verarbeitet wird, muss man beim zweiten IF prüfen, ob das vorherige IF überhaupt true war. Wenn man beim zweiten IF ankommt, befinden sich auf dem Stack die Werte (true, false). Die Bedingung beim zweiten IF ist also völlig unrelevant (und wird auch gar nicht getestet), da dieser Zweig des ersten IF gar nicht ausgeführt wird.

Genau das gleiche Problem gibt es bei der ELSEIF bzw. ELSE Verzweigung. Es ist wichtig ob das übergeordnete IF überhaupt wahr ist oder nicht.

Gruß


----------



## magic_halli (13. Februar 2008)

So, ich habe jetzt den javascript-Code für mein Java analog angepaßt. Allerdings wird bei mir gar nichts zurückgeschrieben!
Annahme meinerseits war nun, dass '_stack.top()_' analog '_stack.peek()_' ist. Außerdem kommt bei mir kein ELSEIF vor, sondern wenn, nur ELSE. Das Textfile ist auch das gleiche geblieben (analog @deepthroat) --> Ausgabe sollte also auch analog @deepthroat sein!
Ich denke, dass ich in meinem Code bestimmt etwas falsch geschrieben bzw. übersehen habe?!
Hier meine jetzige Fassung analog zum Vorschlag @deepthroat:

```
Stack stack = new Stack();
stack.push("true");
//ab hier jede Zeile vom Textfile durchgehen
...
   if( line.startsWith("IF") || line.startsWith("if") ){
      //wenn IF-Bedingung true zurückliefert, dann...
      if( ifcheck == true ){
         stack.push( stack.peek() + "true" );
      } else{
         stack.push( stack.peek() + "false" );
      }
   }else if( line.startsWith("ELSE") || line.startsWith("else") ){
      //bei ELSE Stack negieren
      if( stack.peek().equals("true") ){
         //Element löschen und (neues)negiertes Element hinzufügen
         stack.pop();
         stack.push( stack.peek() + "false" );
      } else{
         stack.pop();
         stack.push( stack.peek() + "true" );
      }
   } else if( line.startsWith("ENDIF") || line.startsWith("endif") ){
      //Wert vom Stack löschen
      stack.pop();
   }
   //nur relevante Zeilen speichern
   else if( stack.peek().equals("true") ){
      strBuffer.append(line + "\n");
   }
```
Was habe ich hier falsch gemacht bzw. übersehen?

Gruß.


----------



## deepthroat (13. Februar 2008)

Hi.

Wie bereits gesagt: es ist keine gute Idee da Strings auf den Stack zu schreiben. So wie es jetzt ist hast du auf dem Stack Werte wie "truefalse", "truetruefalsefalsefalse" etc.

Du solltest einfach den Typ boolean verwenden (bzw. die Klasse Boolean) wie ich bereits angesprochen hatte.

Gruß


----------



## magic_halli (13. Februar 2008)

> Du solltest einfach den Typ boolean verwenden (bzw. die Klasse Boolean) wie ich bereits angesprochen hatte.


OMG, ich breche mir jetzt schon ewig einen aus der Krone, um nicht mit Strings, sondern mit Boolean zu arbeiten. 
1. muß ich immer casten, wg. Java1.4
2. wie negiere ich einen Boolean? (Geht irgendwie nicht)

```
...
} else if( line.startsWith("ELSE") || line.startsWith("else") ){
   //bei ELSE Stack negieren
   Boolean bool = (Boolean) stack.pop();
   stack.push( ! bool );    //ist nicht erlaubt
```

Das leuchtet mir nun auch ein, dass ich keine Strings, sondern gleich die boolschen Werte auf den Stack speichern soll/kann... aber wie schon gesagt, es gibt noch einige Probleme 
Wie schreibe ich das syntaktisch richtig?


----------



## deepthroat (13. Februar 2008)

Hi.





magic_halli hat gesagt.:


> OMG, ich breche mir jetzt schon ewig einen aus der Krone, um nicht mit Strings, sondern mit Boolean zu arbeiten.
> 1. muß ich immer casten, wg. Java1.4


Autsch. 


magic_halli hat gesagt.:


> 2. wie negiere ich einen Boolean? (Geht irgendwie nicht)
> 
> ```
> ...
> ...


Versuch's mal so
	
	
	



```
Boolean bool = (Boolean)stack.pop();
stack.push(Boolean.valueOf(!bool.booleanValue()));
```
Oder evtl. einfacher (ohne Cast ):
	
	
	



```
Object bool = stack.pop();
if (bool.equals(Boolean.TRUE)) {
  stack.push(Boolean.FALSE);
} else {
  stack.push(Boolean.TRUE);
}
```
Gruß


----------



## magic_halli (13. Februar 2008)

deepthroat hat gesagt.:


> Hi.
> ...
> Hier mal ein Test in JavaScript (kannst du ja einfach übersetzen):
> 
> ...



So, das habe ich jetzt 1:1 in Java1.4 übersetzt, oder! Leider bekomme ich nicht Deine Ergebnisse raus! Ich bekomme raus:

```
textzeile2
textzeile3
textzeile6
textzeile7
textzeile9
```
_textzeile2_ und _textzeile3_ sollten eigentlich nicht mit aufgeführt werden
Mein Code sieht jetzt so aus:

```
Stack stack = new Stack();
stack.push( new Boolean(true) );
//ab hier jede Zeile durchgehen
...
   if( line.startsWith("IF") || line.startsWith("if") ){
      //prüfen der IF-Bedingung, ob TRUE oder FALSE
      ifcheck = berechnenIf(sLinks, sOperator, sRechts);
      //ifcheck = true/false auf Stack schreiben
      stack.push( Boolean.valueOf(ifcheck) );
   } else if( line.startsWith("ELSE") || line.startsWith("else") ){
      //bei ELSE Stack negieren        			
      if ( stack.peek().equals(Boolean.TRUE) ) {
         stack.pop();
         stack.push( Boolean.FALSE );
      } else {
         stack.pop();
         stack.push( Boolean.TRUE );
      } 
   } else if( line.startsWith("ENDIF") || line.startsWith("endif") ){
      //Wert vom Stack löschen
      stack.pop();
   }
   //Auswahl der relevanten Zeilen
   else if( stack.peek().equals(Boolean.TRUE) ){
      //Zeilen hinzufügen
      strBuffer.append(line + "\n");
   }
```
Wo ich mir einen Fehler vorstellen könnte ist meine Abfrage für ELSE?! Bei Deinem javascript-Code siehts ja so aus:

```
var b = stack.pop();
stack.push(stack.top() && !b);
```
Doch wie setzt man das in Java1.4 um, speziell die &&-Verknüpfung oder was das sein soll? Das würde ja heißen (in Worten): stack.push setzt sich zusammen aus stack.peek() && der Negation aus dem gelöschten obersten Stackwert. Wie sieht das denn syntaktisch in Java1.4 aus? 

Gruß


----------



## deepthroat (13. Februar 2008)

magic_halli hat gesagt.:


> So, das habe ich jetzt 1:1 in Java1.4 übersetzt, oder!


Nicht ganz.. ;-)


magic_halli hat gesagt.:


> ```
> if( line.startsWith("IF") || line.startsWith("if") ){
> //prüfen der IF-Bedingung, ob TRUE oder FALSE
> ifcheck = berechnenIf(sLinks, sOperator, sRechts);
> ...


Hier hast du vergessen den Wert des übergeordneten IF mittels peek() mit dem aktuellen Wert zu kombinieren. Du mußt das IF nur berechnen, wenn auf dem Stack der Wert TRUE liegt. Ansonsten einfach nur Boolean.FALSE auf den Stack schieben.


magic_halli hat gesagt.:


> Wo ich mir einen Fehler vorstellen könnte ist meine Abfrage für ELSE?! Bei Deinem javascript-Code siehts ja so aus:
> 
> ```
> var b = stack.pop();
> ...


Fast genauso:
	
	
	



```
boolean b = stack.pop().equals(Boolean.TRUE);
stack.push(Boolean.valueOf(stack.peek().equals(Boolean.TRUE) && !b));
```
Gruß


----------



## magic_halli (13. Februar 2008)

Yeah, es geht endlich! 
Ich habs jetzt mit verschiedenen IF-ELSE-ENDIF Konstellationen getestet - sieht sehr gut aus.
Hier nun der endgültige Code:

```
Stack stack = new Stack();
stack.push( new Boolean(true) );

//ab hier jede Zeile durchgehen
...
   if( line.startsWith("IF") || line.startsWith("if") ){
      //prüfen der IF-Bedingung, ob TRUE oder FALSE
      ifcheck = berechnenIf(sLinks, sOperator, sRechts);
      //wenn IF-Bedingung true zurückliefert, dann...
      if( stack.peek().equals(Boolean.TRUE) ){
         stack.push( Boolean.valueOf(stack.peek().equals(Boolean.TRUE) && ifcheck) );
      }else{
         stack.push( Boolean.FALSE );
      }
   } else if( line.startsWith("ELSE") || line.startsWith("else") ){
      //bei ELSE Stack negieren           
      boolean b = stack.pop().equals(Boolean.TRUE);
      stack.push( Boolean.valueOf(stack.peek().equals(Boolean.TRUE) && !b) );
   } else if( line.startsWith("ENDIF") || line.startsWith("endif") ){
      //Wert vom Stack löschen
      stack.pop();
   }
   //Auswahl der relevanten Zeilen
   else if( stack.peek().equals(Boolean.TRUE) ){
      //Zeilen hinzufügen
      strBuffer.append(line + "\n");
   }
```
Ich danke Dir echt wie verrückt... ich war schon kurz vorm Fenstersprung! 

Eine Sache interessiert mich noch bzw. ist mir nicht ganz klar:

```
boolean b = stack.pop().equals(Boolean.TRUE);
stack.push( Boolean.valueOf(stack.peek().equals(Boolean.TRUE) && !b) );
```
Ist das eine logische Auswertung bzw. Verknüpfung? 
Also ich meine: Bei einem ELSE wird das oberste Stackelement gelöscht, der Wert wird aber noch in b gespeichert (bspw. TRUE). Dann wird gepusht und zwar ein TRUE, wenn der nun oberste Wert (durch peek() ermittelt) TRUE ist UND (&&) b eben auch TRUE ist? Wäre b FALSE, dann würde auch nur FALSE gepusht werden, oder?
Das ist hier eigentlich die zentrale Stelle, welche bei der ganzen Geschichte in die Tiefe geht?!
Hab ich das so richtig interpretiert?


----------



## deepthroat (13. Februar 2008)

Hi.





magic_halli hat gesagt.:


> Ich danke Dir echt wie verrückt... ich war schon kurz vorm Fenstersprung!


Oh je, ich hatte ja keine Ahnung wie schlimm es stand.. 


magic_halli hat gesagt.:


> Eine Sache interessiert mich noch bzw. ist mir nicht ganz klar:
> 
> ```
> boolean b = stack.pop().equals(Boolean.TRUE);
> ...


Ja, der && Operator ist das logische UND. 


magic_halli hat gesagt.:


> Also ich meine: Bei einem ELSE wird das oberste Stackelement gelöscht, der Wert wird aber noch in b gespeichert (bspw. TRUE).


Richtig.


magic_halli hat gesagt.:


> Dann wird gepusht und zwar ein TRUE, wenn der nun oberste Wert (durch peek() ermittelt) TRUE ist UND (&&) b eben auch TRUE ist?


Nein, falls !b WAHR ist, also wenn der peek() Wert TRUE und b FALSE ist.


magic_halli hat gesagt.:


> Wäre b FALSE, dann würde auch nur FALSE gepusht werden, oder?


Der && Operator evaluiert nur zu TRUE wenn beide Operanden TRUE sind, also wenn peek() TRUE ist und wenn !b gleich TRUE (also b gleich FALSE) ist.

Gruß


----------

